summaryrefslogtreecommitdiffstats
path: root/gfx/wr/webrender_api
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/wr/webrender_api')
-rw-r--r--gfx/wr/webrender_api/Cargo.toml28
-rw-r--r--gfx/wr/webrender_api/src/channel.rs180
-rw-r--r--gfx/wr/webrender_api/src/color.rs161
-rw-r--r--gfx/wr/webrender_api/src/display_item.rs1825
-rw-r--r--gfx/wr/webrender_api/src/display_item_cache.rs115
-rw-r--r--gfx/wr/webrender_api/src/display_list.rs2338
-rw-r--r--gfx/wr/webrender_api/src/font.rs442
-rw-r--r--gfx/wr/webrender_api/src/gradient_builder.rs180
-rw-r--r--gfx/wr/webrender_api/src/image.rs584
-rw-r--r--gfx/wr/webrender_api/src/lib.rs809
-rw-r--r--gfx/wr/webrender_api/src/units.rs346
11 files changed, 7008 insertions, 0 deletions
diff --git a/gfx/wr/webrender_api/Cargo.toml b/gfx/wr/webrender_api/Cargo.toml
new file mode 100644
index 0000000000..a679fe1e5b
--- /dev/null
+++ b/gfx/wr/webrender_api/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "webrender_api"
+version = "0.62.0"
+authors = ["Glenn Watson <gw@intuitionlibrary.com>"]
+license = "MPL-2.0"
+repository = "https://github.com/servo/webrender"
+description = "Public API for WebRender"
+edition = "2018"
+
+[features]
+nightly = ["euclid/unstable", "serde/unstable"]
+serialize = []
+deserialize = []
+display_list_stats = []
+
+[dependencies]
+app_units = "0.7.3"
+bitflags = { version = "2", features = ["serde"] }
+byteorder = "1.2.1"
+euclid = { version = "0.22.6", features = ["serde"] }
+malloc_size_of_derive = "0.1"
+serde = { version = "1.0", features = ["rc"] }
+serde_derive = "1.0"
+serde_bytes = "0.11"
+time = "0.1"
+malloc_size_of = { version = "0.0.2", path = "../wr_malloc_size_of", package = "wr_malloc_size_of" }
+peek-poke = { version = "0.3", path = "../peek-poke", features = ["extras"] }
+crossbeam-channel = "0.5"
diff --git a/gfx/wr/webrender_api/src/channel.rs b/gfx/wr/webrender_api/src/channel.rs
new file mode 100644
index 0000000000..7d21c6e433
--- /dev/null
+++ b/gfx/wr/webrender_api/src/channel.rs
@@ -0,0 +1,180 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use crate::{Epoch, PipelineId};
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::io::{self, Cursor, Error, ErrorKind, Read};
+use std::mem;
+
+pub use crossbeam_channel as crossbeam;
+
+#[cfg(not(target_os = "windows"))]
+pub use crossbeam_channel::{Sender, Receiver};
+
+#[cfg(target_os = "windows")]
+pub use std::sync::mpsc::{Sender, Receiver};
+
+#[derive(Clone)]
+pub struct Payload {
+ /// An epoch used to get the proper payload for a pipeline id frame request.
+ ///
+ /// TODO(emilio): Is this still relevant? We send the messages for the same
+ /// pipeline in order, so we shouldn't need it. Seems like this was only
+ /// wallpapering (in most cases) the underlying problem in #991.
+ pub epoch: Epoch,
+ /// A pipeline id to key the payload with, along with the epoch.
+ pub pipeline_id: PipelineId,
+ pub display_list_data: Vec<u8>,
+}
+
+impl Payload {
+ /// Convert the payload to a raw byte vector, in order for it to be
+ /// efficiently shared via shmem, for example.
+ /// This is a helper static method working on a slice.
+ pub fn construct_data(epoch: Epoch, pipeline_id: PipelineId, dl_data: &[u8]) -> Vec<u8> {
+ let mut data = Vec::with_capacity(
+ mem::size_of::<u32>() + 2 * mem::size_of::<u32>() + mem::size_of::<u64>() + dl_data.len(),
+ );
+ data.write_u32::<LittleEndian>(epoch.0).unwrap();
+ data.write_u32::<LittleEndian>(pipeline_id.0).unwrap();
+ data.write_u32::<LittleEndian>(pipeline_id.1).unwrap();
+ data.write_u64::<LittleEndian>(dl_data.len() as u64)
+ .unwrap();
+ data.extend_from_slice(dl_data);
+ data
+ }
+ /// Convert the payload to a raw byte vector, in order for it to be
+ /// efficiently shared via shmem, for example.
+ pub fn to_data(&self) -> Vec<u8> {
+ Self::construct_data(self.epoch, self.pipeline_id, &self.display_list_data)
+ }
+
+ /// Deserializes the given payload from a raw byte vector.
+ pub fn from_data(data: &[u8]) -> Payload {
+ let mut payload_reader = Cursor::new(data);
+ let epoch = Epoch(payload_reader.read_u32::<LittleEndian>().unwrap());
+ let pipeline_id = PipelineId(
+ payload_reader.read_u32::<LittleEndian>().unwrap(),
+ payload_reader.read_u32::<LittleEndian>().unwrap(),
+ );
+
+ let dl_size = payload_reader.read_u64::<LittleEndian>().unwrap() as usize;
+ let mut built_display_list_data = vec![0; dl_size];
+ payload_reader
+ .read_exact(&mut built_display_list_data[..])
+ .unwrap();
+
+ assert_eq!(payload_reader.position(), data.len() as u64);
+
+ Payload {
+ epoch,
+ pipeline_id,
+ display_list_data: built_display_list_data,
+ }
+ }
+}
+
+pub type PayloadSender = MsgSender<Payload>;
+
+pub type PayloadReceiver = MsgReceiver<Payload>;
+
+pub struct MsgReceiver<T> {
+ rx: Receiver<T>,
+}
+
+impl<T> MsgReceiver<T> {
+ pub fn recv(&self) -> Result<T, Error> {
+ self.rx.recv().map_err(|e| io::Error::new(ErrorKind::Other, e.to_string()))
+ }
+
+ pub fn to_crossbeam_receiver(self) -> Receiver<T> {
+ self.rx
+ }
+}
+
+#[derive(Clone)]
+pub struct MsgSender<T> {
+ tx: Sender<T>,
+}
+
+impl<T> MsgSender<T> {
+ pub fn send(&self, data: T) -> Result<(), Error> {
+ self.tx.send(data).map_err(|_| Error::new(ErrorKind::Other, "cannot send on closed channel"))
+ }
+}
+
+pub fn payload_channel() -> Result<(PayloadSender, PayloadReceiver), Error> {
+ let (tx, rx) = unbounded_channel();
+ Ok((PayloadSender { tx }, PayloadReceiver { rx }))
+}
+
+pub fn msg_channel<T>() -> Result<(MsgSender<T>, MsgReceiver<T>), Error> {
+ let (tx, rx) = unbounded_channel();
+ Ok((MsgSender { tx }, MsgReceiver { rx }))
+}
+
+///
+/// These serialize methods are needed to satisfy the compiler
+/// which uses these implementations for the recording tool.
+/// The recording tool only outputs messages that don't contain
+/// Senders or Receivers, so in theory these should never be
+/// called in the in-process config. If they are called,
+/// there may be a bug in the messages that the replay tool is writing.
+///
+
+impl<T> Serialize for MsgSender<T> {
+ fn serialize<S: Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
+ unreachable!();
+ }
+}
+
+impl<'de, T> Deserialize<'de> for MsgSender<T> {
+ fn deserialize<D>(_: D) -> Result<MsgSender<T>, D::Error>
+ where D: Deserializer<'de> {
+ unreachable!();
+ }
+}
+
+/// A create a channel intended for one-shot uses, for example the channels
+/// created to block on a synchronous query and then discarded,
+#[cfg(not(target_os = "windows"))]
+pub fn single_msg_channel<T>() -> (Sender<T>, Receiver<T>) {
+ crossbeam_channel::bounded(1)
+}
+
+/// A fast MPMC message channel that can hold a fixed number of messages.
+///
+/// If the channel is full, the sender will block upon sending extra messages
+/// until the receiver has consumed some messages.
+/// The capacity parameter should be chosen either:
+/// - high enough to avoid blocking on the common cases,
+/// - or, on the contrary, using the blocking behavior as a means to prevent
+/// fast producers from building up work faster than it is consumed.
+#[cfg(not(target_os = "windows"))]
+pub fn fast_channel<T>(capacity: usize) -> (Sender<T>, Receiver<T>) {
+ crossbeam_channel::bounded(capacity)
+}
+
+/// Creates an MPMC channel that is a bit slower than the fast_channel but doesn't
+/// have a limit on the number of messages held at a given time and therefore
+/// doesn't block when sending.
+#[cfg(not(target_os = "windows"))]
+pub use crossbeam_channel::unbounded as unbounded_channel;
+
+
+#[cfg(target_os = "windows")]
+pub fn fast_channel<T>(_cap: usize) -> (Sender<T>, Receiver<T>) {
+ std::sync::mpsc::channel()
+}
+
+#[cfg(target_os = "windows")]
+pub fn unbounded_channel<T>() -> (Sender<T>, Receiver<T>) {
+ std::sync::mpsc::channel()
+}
+
+#[cfg(target_os = "windows")]
+pub fn single_msg_channel<T>() -> (Sender<T>, Receiver<T>) {
+ std::sync::mpsc::channel()
+}
diff --git a/gfx/wr/webrender_api/src/color.rs b/gfx/wr/webrender_api/src/color.rs
new file mode 100644
index 0000000000..4b0a43a10d
--- /dev/null
+++ b/gfx/wr/webrender_api/src/color.rs
@@ -0,0 +1,161 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use peek_poke::PeekPoke;
+use std::cmp;
+use std::hash::{Hash, Hasher};
+
+/// Represents pre-multiplied RGBA colors with floating point numbers.
+///
+/// All components must be between 0.0 and 1.0.
+/// An alpha value of 1.0 is opaque while 0.0 is fully transparent.
+///
+/// In premultiplied colors transitions to transparent always look "nice"
+/// therefore they are used in CSS gradients.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
+pub struct PremultipliedColorF {
+ pub r: f32,
+ pub g: f32,
+ pub b: f32,
+ pub a: f32,
+}
+
+#[allow(missing_docs)]
+impl PremultipliedColorF {
+ pub const BLACK: PremultipliedColorF = PremultipliedColorF { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };
+ pub const TRANSPARENT: PremultipliedColorF = PremultipliedColorF { r: 0.0, g: 0.0, b: 0.0, a: 0.0 };
+ pub const WHITE: PremultipliedColorF = PremultipliedColorF { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
+
+ pub fn to_array(&self) -> [f32; 4] {
+ [self.r, self.g, self.b, self.a]
+ }
+}
+
+/// Represents RGBA screen colors with floating point numbers.
+///
+/// All components must be between 0.0 and 1.0.
+/// An alpha value of 1.0 is opaque while 0.0 is fully transparent.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct ColorF {
+ pub r: f32,
+ pub g: f32,
+ pub b: f32,
+ pub a: f32,
+}
+
+#[allow(missing_docs)]
+impl ColorF {
+ pub const BLACK: ColorF = ColorF { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };
+ pub const TRANSPARENT: ColorF = ColorF { r: 0.0, g: 0.0, b: 0.0, a: 0.0 };
+ pub const WHITE: ColorF = ColorF { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
+
+ /// Constructs a new `ColorF` from its components.
+ pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
+ ColorF { r, g, b, a }
+ }
+
+ /// Multiply the RGB channels (but not alpha) with a given factor.
+ pub fn scale_rgb(&self, scale: f32) -> Self {
+ ColorF {
+ r: self.r * scale,
+ g: self.g * scale,
+ b: self.b * scale,
+ a: self.a,
+ }
+ }
+
+ // Scale the alpha by a given factor.
+ pub fn scale_alpha(&self, scale: f32) -> Self {
+ ColorF {
+ r: self.r,
+ g: self.g,
+ b: self.b,
+ a: self.a * scale,
+ }
+ }
+
+ pub fn to_array(&self) -> [f32; 4] {
+ [self.r, self.g, self.b, self.a]
+ }
+
+ /// Multiply the RGB components with the alpha channel.
+ pub fn premultiplied(&self) -> PremultipliedColorF {
+ let c = self.scale_rgb(self.a);
+ PremultipliedColorF { r: c.r, g: c.g, b: c.b, a: c.a }
+ }
+}
+
+// Floats don't impl Hash/Eq/Ord...
+impl Eq for PremultipliedColorF {}
+impl Ord for PremultipliedColorF {
+ fn cmp(&self, other: &Self) -> cmp::Ordering {
+ self.partial_cmp(other).unwrap_or(cmp::Ordering::Equal)
+ }
+}
+
+#[cfg_attr(feature = "cargo-clippy", allow(clippy::derive_hash_xor_eq))]
+impl Hash for PremultipliedColorF {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ // Note: this is inconsistent with the Eq impl for -0.0 (don't care).
+ self.r.to_bits().hash(state);
+ self.g.to_bits().hash(state);
+ self.b.to_bits().hash(state);
+ self.a.to_bits().hash(state);
+ }
+}
+
+/// Represents RGBA screen colors with one byte per channel.
+///
+/// If the alpha value `a` is 255 the color is opaque.
+#[repr(C)]
+#[derive(Clone, Copy, Hash, Eq, Debug, Deserialize, MallocSizeOf, PartialEq)]
+#[derive(PartialOrd, Ord, Serialize, PeekPoke, Default)]
+pub struct ColorU {
+ pub r: u8,
+ pub g: u8,
+ pub b: u8,
+ pub a: u8,
+}
+
+impl ColorU {
+ /// Constructs a new additive `ColorU` from its components.
+ pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self {
+ ColorU { r, g, b, a }
+ }
+}
+
+fn round_to_int(x: f32) -> u8 {
+ debug_assert!((0.0 <= x) && (x <= 1.0), "{} should be between 0 and 1", x);
+ let f = (255.0 * x) + 0.5;
+ let val = f.floor();
+ debug_assert!(val <= 255.0);
+ val as u8
+}
+
+// TODO: We shouldn't really convert back to `ColorU` ever,
+// since it's lossy. One of the blockers is that all of our debug colors
+// are specified in `ColorF`. Changing it to `ColorU` would be nice.
+impl From<ColorF> for ColorU {
+ fn from(color: ColorF) -> Self {
+ ColorU {
+ r: round_to_int(color.r),
+ g: round_to_int(color.g),
+ b: round_to_int(color.b),
+ a: round_to_int(color.a),
+ }
+ }
+}
+
+impl From<ColorU> for ColorF {
+ fn from(color: ColorU) -> Self {
+ ColorF {
+ r: color.r as f32 / 255.0,
+ g: color.g as f32 / 255.0,
+ b: color.b as f32 / 255.0,
+ a: color.a as f32 / 255.0,
+ }
+ }
+}
diff --git a/gfx/wr/webrender_api/src/display_item.rs b/gfx/wr/webrender_api/src/display_item.rs
new file mode 100644
index 0000000000..190d36ccba
--- /dev/null
+++ b/gfx/wr/webrender_api/src/display_item.rs
@@ -0,0 +1,1825 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use euclid::{SideOffsets2D, Angle};
+use peek_poke::PeekPoke;
+use std::ops::Not;
+// local imports
+use crate::font;
+use crate::{APZScrollGeneration, HasScrollLinkedEffect, PipelineId, PropertyBinding};
+use crate::color::ColorF;
+use crate::image::{ColorDepth, ImageKey};
+use crate::units::*;
+use std::hash::{Hash, Hasher};
+
+// ******************************************************************
+// * NOTE: some of these structs have an "IMPLICIT" comment. *
+// * This indicates that the BuiltDisplayList will have serialized *
+// * a list of values nearby that this item consumes. The traversal *
+// * iterator should handle finding these. DebugDisplayItem should *
+// * make them explicit. *
+// ******************************************************************
+
+/// A tag that can be used to identify items during hit testing. If the tag
+/// is missing then the item doesn't take part in hit testing at all. This
+/// is composed of two numbers. In Servo, the first is an identifier while the
+/// second is used to select the cursor that should be used during mouse
+/// movement. In Gecko, the first is a scrollframe identifier, while the second
+/// is used to store various flags that APZ needs to properly process input
+/// events.
+pub type ItemTag = (u64, u16);
+
+/// An identifier used to refer to previously sent display items. Currently it
+/// refers to individual display items, but this may change later.
+pub type ItemKey = u16;
+
+#[repr(C)]
+#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Deserialize, MallocSizeOf, Serialize, PeekPoke)]
+pub struct PrimitiveFlags(u8);
+
+bitflags! {
+ impl PrimitiveFlags: u8 {
+ /// The CSS backface-visibility property (yes, it can be really granular)
+ const IS_BACKFACE_VISIBLE = 1 << 0;
+ /// If set, this primitive represents a scroll bar container
+ const IS_SCROLLBAR_CONTAINER = 1 << 1;
+ /// This is used as a performance hint - this primitive may be promoted to a native
+ /// compositor surface under certain (implementation specific) conditions. This
+ /// is typically used for large videos, and canvas elements.
+ const PREFER_COMPOSITOR_SURFACE = 1 << 2;
+ /// If set, this primitive can be passed directly to the compositor via its
+ /// ExternalImageId, and the compositor will use the native image directly.
+ /// Used as a further extension on top of PREFER_COMPOSITOR_SURFACE.
+ const SUPPORTS_EXTERNAL_COMPOSITOR_SURFACE = 1 << 3;
+ /// This flags disables snapping and forces anti-aliasing even if the primitive is axis-aligned.
+ const ANTIALISED = 1 << 4;
+ /// If true, this primitive is used as a background for checkerboarding
+ const CHECKERBOARD_BACKGROUND = 1 << 5;
+ }
+}
+
+impl core::fmt::Debug for PrimitiveFlags {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.is_empty() {
+ write!(f, "{:#x}", Self::empty().bits())
+ } else {
+ bitflags::parser::to_writer(self, f)
+ }
+ }
+}
+
+impl Default for PrimitiveFlags {
+ fn default() -> Self {
+ PrimitiveFlags::IS_BACKFACE_VISIBLE
+ }
+}
+
+/// A grouping of fields a lot of display items need, just to avoid
+/// repeating these over and over in this file.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct CommonItemProperties {
+ /// Bounds of the display item to clip to. Many items are logically
+ /// infinite, and rely on this clip_rect to define their bounds
+ /// (solid colors, background-images, gradients, etc).
+ pub clip_rect: LayoutRect,
+ /// Additional clips
+ pub clip_chain_id: ClipChainId,
+ /// The coordinate-space the item is in (yes, it can be really granular)
+ pub spatial_id: SpatialId,
+ /// Various flags describing properties of this primitive.
+ pub flags: PrimitiveFlags,
+}
+
+impl CommonItemProperties {
+ /// Convenience for tests.
+ pub fn new(
+ clip_rect: LayoutRect,
+ space_and_clip: SpaceAndClipInfo,
+ ) -> Self {
+ Self {
+ clip_rect,
+ spatial_id: space_and_clip.spatial_id,
+ clip_chain_id: space_and_clip.clip_chain_id,
+ flags: PrimitiveFlags::default(),
+ }
+ }
+}
+
+/// Per-primitive information about the nodes in the clip tree and
+/// the spatial tree that the primitive belongs to.
+///
+/// Note: this is a separate struct from `PrimitiveInfo` because
+/// it needs indirectional mapping during the DL flattening phase,
+/// turning into `ScrollNodeAndClipChain`.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct SpaceAndClipInfo {
+ pub spatial_id: SpatialId,
+ pub clip_chain_id: ClipChainId,
+}
+
+impl SpaceAndClipInfo {
+ /// Create a new space/clip info associated with the root
+ /// scroll frame.
+ pub fn root_scroll(pipeline_id: PipelineId) -> Self {
+ SpaceAndClipInfo {
+ spatial_id: SpatialId::root_scroll_node(pipeline_id),
+ clip_chain_id: ClipChainId::INVALID,
+ }
+ }
+}
+
+/// Defines a caller provided key that is unique for a given spatial node, and is stable across
+/// display lists. WR uses this to determine which spatial nodes are added / removed for a new
+/// display list. The content itself is arbitrary and opaque to WR, the only thing that matters
+/// is that it's unique and stable between display lists.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke, Default, Eq, Hash)]
+pub struct SpatialTreeItemKey {
+ key0: u64,
+ key1: u64,
+}
+
+impl SpatialTreeItemKey {
+ pub fn new(key0: u64, key1: u64) -> Self {
+ SpatialTreeItemKey {
+ key0,
+ key1,
+ }
+ }
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum SpatialTreeItem {
+ ScrollFrame(ScrollFrameDescriptor),
+ ReferenceFrame(ReferenceFrameDescriptor),
+ StickyFrame(StickyFrameDescriptor),
+ Invalid,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum DisplayItem {
+ // These are the "real content" display items
+ Rectangle(RectangleDisplayItem),
+ ClearRectangle(ClearRectangleDisplayItem),
+ HitTest(HitTestDisplayItem),
+ Text(TextDisplayItem),
+ Line(LineDisplayItem),
+ Border(BorderDisplayItem),
+ BoxShadow(BoxShadowDisplayItem),
+ PushShadow(PushShadowDisplayItem),
+ Gradient(GradientDisplayItem),
+ RadialGradient(RadialGradientDisplayItem),
+ ConicGradient(ConicGradientDisplayItem),
+ Image(ImageDisplayItem),
+ RepeatingImage(RepeatingImageDisplayItem),
+ YuvImage(YuvImageDisplayItem),
+ BackdropFilter(BackdropFilterDisplayItem),
+
+ // Clips
+ RectClip(RectClipDisplayItem),
+ RoundedRectClip(RoundedRectClipDisplayItem),
+ ImageMaskClip(ImageMaskClipDisplayItem),
+ ClipChain(ClipChainItem),
+
+ // Spaces and Frames that content can be scoped under.
+ Iframe(IframeDisplayItem),
+ PushReferenceFrame(ReferenceFrameDisplayListItem),
+ PushStackingContext(PushStackingContextDisplayItem),
+
+ // These marker items indicate an array of data follows, to be used for the
+ // next non-marker item.
+ SetGradientStops,
+ SetFilterOps,
+ SetFilterData,
+ SetFilterPrimitives,
+ SetPoints,
+
+ // These marker items terminate a scope introduced by a previous item.
+ PopReferenceFrame,
+ PopStackingContext,
+ PopAllShadows,
+
+ ReuseItems(ItemKey),
+ RetainedItems(ItemKey),
+}
+
+/// This is a "complete" version of the DisplayItem, with all implicit trailing
+/// arrays included, for debug serialization (captures).
+#[cfg(any(feature = "serialize", feature = "deserialize"))]
+#[cfg_attr(feature = "serialize", derive(Serialize))]
+#[cfg_attr(feature = "deserialize", derive(Deserialize))]
+pub enum DebugDisplayItem {
+ Rectangle(RectangleDisplayItem),
+ ClearRectangle(ClearRectangleDisplayItem),
+ HitTest(HitTestDisplayItem),
+ Text(TextDisplayItem, Vec<font::GlyphInstance>),
+ Line(LineDisplayItem),
+ Border(BorderDisplayItem),
+ BoxShadow(BoxShadowDisplayItem),
+ PushShadow(PushShadowDisplayItem),
+ Gradient(GradientDisplayItem),
+ RadialGradient(RadialGradientDisplayItem),
+ ConicGradient(ConicGradientDisplayItem),
+ Image(ImageDisplayItem),
+ RepeatingImage(RepeatingImageDisplayItem),
+ YuvImage(YuvImageDisplayItem),
+ BackdropFilter(BackdropFilterDisplayItem),
+
+ ImageMaskClip(ImageMaskClipDisplayItem),
+ RoundedRectClip(RoundedRectClipDisplayItem),
+ RectClip(RectClipDisplayItem),
+ ClipChain(ClipChainItem, Vec<ClipId>),
+
+ Iframe(IframeDisplayItem),
+ PushReferenceFrame(ReferenceFrameDisplayListItem),
+ PushStackingContext(PushStackingContextDisplayItem),
+
+ SetGradientStops(Vec<GradientStop>),
+ SetFilterOps(Vec<FilterOp>),
+ SetFilterData(FilterData),
+ SetFilterPrimitives(Vec<FilterPrimitive>),
+ SetPoints(Vec<LayoutPoint>),
+
+ PopReferenceFrame,
+ PopStackingContext,
+ PopAllShadows,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ImageMaskClipDisplayItem {
+ pub id: ClipId,
+ pub spatial_id: SpatialId,
+ pub image_mask: ImageMask,
+ pub fill_rule: FillRule,
+} // IMPLICIT points: Vec<LayoutPoint>
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RectClipDisplayItem {
+ pub id: ClipId,
+ pub spatial_id: SpatialId,
+ pub clip_rect: LayoutRect,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RoundedRectClipDisplayItem {
+ pub id: ClipId,
+ pub spatial_id: SpatialId,
+ pub clip: ComplexClipRegion,
+}
+
+/// The minimum and maximum allowable offset for a sticky frame in a single dimension.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct StickyOffsetBounds {
+ /// The minimum offset for this frame, typically a negative value, which specifies how
+ /// far in the negative direction the sticky frame can offset its contents in this
+ /// dimension.
+ pub min: f32,
+
+ /// The maximum offset for this frame, typically a positive value, which specifies how
+ /// far in the positive direction the sticky frame can offset its contents in this
+ /// dimension.
+ pub max: f32,
+}
+
+impl StickyOffsetBounds {
+ pub fn new(min: f32, max: f32) -> StickyOffsetBounds {
+ StickyOffsetBounds { min, max }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct StickyFrameDescriptor {
+ pub id: SpatialId,
+ pub parent_spatial_id: SpatialId,
+ pub bounds: LayoutRect,
+
+ /// The margins that should be maintained between the edge of the parent viewport and this
+ /// sticky frame. A margin of None indicates that the sticky frame should not stick at all
+ /// to that particular edge of the viewport.
+ pub margins: SideOffsets2D<Option<f32>, LayoutPixel>,
+
+ /// The minimum and maximum vertical offsets for this sticky frame. Ignoring these constraints,
+ /// the sticky frame will continue to stick to the edge of the viewport as its original
+ /// position is scrolled out of view. Constraints specify a maximum and minimum offset from the
+ /// original position relative to non-sticky content within the same scrolling frame.
+ pub vertical_offset_bounds: StickyOffsetBounds,
+
+ /// The minimum and maximum horizontal offsets for this sticky frame. Ignoring these constraints,
+ /// the sticky frame will continue to stick to the edge of the viewport as its original
+ /// position is scrolled out of view. Constraints specify a maximum and minimum offset from the
+ /// original position relative to non-sticky content within the same scrolling frame.
+ pub horizontal_offset_bounds: StickyOffsetBounds,
+
+ /// The amount of offset that has already been applied to the sticky frame. A positive y
+ /// component this field means that a top-sticky item was in a scrollframe that has been
+ /// scrolled down, such that the sticky item's position needed to be offset downwards by
+ /// `previously_applied_offset.y`. A negative y component corresponds to the upward offset
+ /// applied due to bottom-stickiness. The x-axis works analogously.
+ pub previously_applied_offset: LayoutVector2D,
+
+ /// A unique (per-pipeline) key for this spatial that is stable across display lists.
+ pub key: SpatialTreeItemKey,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ScrollFrameDescriptor {
+ /// The id of the space this scroll frame creates
+ pub scroll_frame_id: SpatialId,
+ /// The size of the contents this contains (so the backend knows how far it can scroll).
+ // FIXME: this can *probably* just be a size? Origin seems to just get thrown out.
+ pub content_rect: LayoutRect,
+ pub frame_rect: LayoutRect,
+ pub parent_space: SpatialId,
+ pub external_id: ExternalScrollId,
+ /// The amount this scrollframe has already been scrolled by, in the caller.
+ /// This means that all the display items that are inside the scrollframe
+ /// will have their coordinates shifted by this amount, and this offset
+ /// should be added to those display item coordinates in order to get a
+ /// normalized value that is consistent across display lists.
+ pub external_scroll_offset: LayoutVector2D,
+ /// The generation of the external_scroll_offset.
+ pub scroll_offset_generation: APZScrollGeneration,
+ /// Whether this scrollframe document has any scroll-linked effect or not.
+ pub has_scroll_linked_effect: HasScrollLinkedEffect,
+ /// A unique (per-pipeline) key for this spatial that is stable across display lists.
+ pub key: SpatialTreeItemKey,
+}
+
+/// A solid or an animating color to draw (may not actually be a rectangle due to complex clips)
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RectangleDisplayItem {
+ pub common: CommonItemProperties,
+ pub bounds: LayoutRect,
+ pub color: PropertyBinding<ColorF>,
+}
+
+/// Clears all colors from the area, making it possible to cut holes in the window.
+/// (useful for things like the macos frosted-glass effect).
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ClearRectangleDisplayItem {
+ pub common: CommonItemProperties,
+ pub bounds: LayoutRect,
+}
+
+/// A minimal hit-testable item for the parent browser's convenience, and is
+/// slimmer than a RectangleDisplayItem (no color). The existence of this as a
+/// distinct item also makes it easier to inspect/debug display items.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct HitTestDisplayItem {
+ pub rect: LayoutRect,
+ pub clip_chain_id: ClipChainId,
+ pub spatial_id: SpatialId,
+ pub flags: PrimitiveFlags,
+ pub tag: ItemTag,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct LineDisplayItem {
+ pub common: CommonItemProperties,
+ /// We need a separate rect from common.clip_rect to encode cute
+ /// tricks that firefox does to make a series of text-decorations seamlessly
+ /// line up -- snapping the decorations to a multiple of their period, and
+ /// then clipping them to their "proper" area. This rect is that "logical"
+ /// snapped area that may be clipped to the right size by the clip_rect.
+ pub area: LayoutRect,
+ /// Whether the rect is interpretted as vertical or horizontal
+ pub orientation: LineOrientation,
+ /// This could potentially be implied from area, but we currently prefer
+ /// that this is the responsibility of the layout engine. Value irrelevant
+ /// for non-wavy lines.
+ // FIXME: this was done before we could use tagged unions in enums, but now
+ // it should just be part of LineStyle::Wavy.
+ pub wavy_line_thickness: f32,
+ pub color: ColorF,
+ pub style: LineStyle,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, Eq, Hash, PeekPoke)]
+pub enum LineOrientation {
+ Vertical,
+ Horizontal,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, Eq, Hash, PeekPoke)]
+pub enum LineStyle {
+ Solid,
+ Dotted,
+ Dashed,
+ Wavy,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct TextDisplayItem {
+ pub common: CommonItemProperties,
+ /// The area all the glyphs should be found in. Strictly speaking this isn't
+ /// necessarily needed, but layout engines should already "know" this, and we
+ /// use it cull and size things quickly before glyph layout is done. Currently
+ /// the glyphs *can* be outside these bounds, but that should imply they
+ /// can be cut off.
+ // FIXME: these are currently sometimes ignored to keep some old wrench tests
+ // working, but we should really just fix the tests!
+ pub bounds: LayoutRect,
+ pub font_key: font::FontInstanceKey,
+ pub color: ColorF,
+ pub glyph_options: Option<font::GlyphOptions>,
+} // IMPLICIT: glyphs: Vec<font::GlyphInstance>
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct NormalBorder {
+ pub left: BorderSide,
+ pub right: BorderSide,
+ pub top: BorderSide,
+ pub bottom: BorderSide,
+ pub radius: BorderRadius,
+ /// Whether to apply anti-aliasing on the border corners.
+ ///
+ /// Note that for this to be `false` and work, this requires the borders to
+ /// be solid, and no border-radius.
+ pub do_aa: bool,
+}
+
+impl NormalBorder {
+ fn can_disable_antialiasing(&self) -> bool {
+ fn is_valid(style: BorderStyle) -> bool {
+ style == BorderStyle::Solid || style == BorderStyle::None
+ }
+
+ self.radius.is_zero() &&
+ is_valid(self.top.style) &&
+ is_valid(self.left.style) &&
+ is_valid(self.bottom.style) &&
+ is_valid(self.right.style)
+ }
+
+ /// Normalizes a border so that we don't render disallowed stuff, like inset
+ /// borders that are less than two pixels wide.
+ #[inline]
+ pub fn normalize(&mut self, widths: &LayoutSideOffsets) {
+ debug_assert!(
+ self.do_aa || self.can_disable_antialiasing(),
+ "Unexpected disabled-antialiasing in a border, likely won't work or will be ignored"
+ );
+
+ #[inline]
+ fn renders_small_border_solid(style: BorderStyle) -> bool {
+ match style {
+ BorderStyle::Groove |
+ BorderStyle::Ridge => true,
+ _ => false,
+ }
+ }
+
+ let normalize_side = |side: &mut BorderSide, width: f32| {
+ if renders_small_border_solid(side.style) && width < 2. {
+ side.style = BorderStyle::Solid;
+ }
+ };
+
+ normalize_side(&mut self.left, widths.left);
+ normalize_side(&mut self.right, widths.right);
+ normalize_side(&mut self.top, widths.top);
+ normalize_side(&mut self.bottom, widths.bottom);
+ }
+}
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, MallocSizeOf, PartialEq, Serialize, Deserialize, Eq, Hash, PeekPoke)]
+pub enum RepeatMode {
+ Stretch,
+ Repeat,
+ Round,
+ Space,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum NinePatchBorderSource {
+ Image(ImageKey, ImageRendering),
+ Gradient(Gradient),
+ RadialGradient(RadialGradient),
+ ConicGradient(ConicGradient),
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct NinePatchBorder {
+ /// Describes what to use as the 9-patch source image. If this is an image,
+ /// it will be stretched to fill the size given by width x height.
+ pub source: NinePatchBorderSource,
+
+ /// The width of the 9-part image.
+ pub width: i32,
+
+ /// The height of the 9-part image.
+ pub height: i32,
+
+ /// Distances from each edge where the image should be sliced up. These
+ /// values are in 9-part-image space (the same space as width and height),
+ /// and the resulting image parts will be used to fill the corresponding
+ /// parts of the border as given by the border widths. This can lead to
+ /// stretching.
+ /// Slices can be overlapping. In that case, the same pixels from the
+ /// 9-part image will show up in multiple parts of the resulting border.
+ pub slice: DeviceIntSideOffsets,
+
+ /// Controls whether the center of the 9 patch image is rendered or
+ /// ignored. The center is never rendered if the slices are overlapping.
+ pub fill: bool,
+
+ /// Determines what happens if the horizontal side parts of the 9-part
+ /// image have a different size than the horizontal parts of the border.
+ pub repeat_horizontal: RepeatMode,
+
+ /// Determines what happens if the vertical side parts of the 9-part
+ /// image have a different size than the vertical parts of the border.
+ pub repeat_vertical: RepeatMode,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum BorderDetails {
+ Normal(NormalBorder),
+ NinePatch(NinePatchBorder),
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct BorderDisplayItem {
+ pub common: CommonItemProperties,
+ pub bounds: LayoutRect,
+ pub widths: LayoutSideOffsets,
+ pub details: BorderDetails,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum BorderRadiusKind {
+ Uniform,
+ NonUniform,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct BorderRadius {
+ pub top_left: LayoutSize,
+ pub top_right: LayoutSize,
+ pub bottom_left: LayoutSize,
+ pub bottom_right: LayoutSize,
+}
+
+impl Default for BorderRadius {
+ fn default() -> Self {
+ BorderRadius {
+ top_left: LayoutSize::zero(),
+ top_right: LayoutSize::zero(),
+ bottom_left: LayoutSize::zero(),
+ bottom_right: LayoutSize::zero(),
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct BorderSide {
+ pub color: ColorF,
+ pub style: BorderStyle,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, Hash, Eq, PeekPoke)]
+pub enum BorderStyle {
+ None = 0,
+ Solid = 1,
+ Double = 2,
+ Dotted = 3,
+ Dashed = 4,
+ Hidden = 5,
+ Groove = 6,
+ Ridge = 7,
+ Inset = 8,
+ Outset = 9,
+}
+
+impl BorderStyle {
+ pub fn is_hidden(self) -> bool {
+ self == BorderStyle::Hidden || self == BorderStyle::None
+ }
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum BoxShadowClipMode {
+ Outset = 0,
+ Inset = 1,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct BoxShadowDisplayItem {
+ pub common: CommonItemProperties,
+ pub box_bounds: LayoutRect,
+ pub offset: LayoutVector2D,
+ pub color: ColorF,
+ pub blur_radius: f32,
+ pub spread_radius: f32,
+ pub border_radius: BorderRadius,
+ pub clip_mode: BoxShadowClipMode,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct PushShadowDisplayItem {
+ pub space_and_clip: SpaceAndClipInfo,
+ pub shadow: Shadow,
+ pub should_inflate: bool,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct Shadow {
+ pub offset: LayoutVector2D,
+ pub color: ColorF,
+ pub blur_radius: f32,
+}
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, Eq, MallocSizeOf, PartialEq, Serialize, Deserialize, Ord, PartialOrd, PeekPoke)]
+pub enum ExtendMode {
+ Clamp,
+ Repeat,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct Gradient {
+ pub start_point: LayoutPoint,
+ pub end_point: LayoutPoint,
+ pub extend_mode: ExtendMode,
+} // IMPLICIT: stops: Vec<GradientStop>
+
+impl Gradient {
+ pub fn is_valid(&self) -> bool {
+ self.start_point.x.is_finite() &&
+ self.start_point.y.is_finite() &&
+ self.end_point.x.is_finite() &&
+ self.end_point.y.is_finite()
+ }
+}
+
+/// The area
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct GradientDisplayItem {
+ /// NOTE: common.clip_rect is the area the gradient covers
+ pub common: CommonItemProperties,
+ /// The area to tile the gradient over (first tile starts at origin of this rect)
+ // FIXME: this should ideally just be `tile_origin` here, with the clip_rect
+ // defining the bounds of the item. Needs non-trivial backend changes.
+ pub bounds: LayoutRect,
+ /// How big a tile of the of the gradient should be (common case: bounds.size)
+ pub tile_size: LayoutSize,
+ /// The space between tiles of the gradient (common case: 0)
+ pub tile_spacing: LayoutSize,
+ pub gradient: Gradient,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct GradientStop {
+ pub offset: f32,
+ pub color: ColorF,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RadialGradient {
+ pub center: LayoutPoint,
+ pub radius: LayoutSize,
+ pub start_offset: f32,
+ pub end_offset: f32,
+ pub extend_mode: ExtendMode,
+} // IMPLICIT stops: Vec<GradientStop>
+
+impl RadialGradient {
+ pub fn is_valid(&self) -> bool {
+ self.center.x.is_finite() &&
+ self.center.y.is_finite() &&
+ self.start_offset.is_finite() &&
+ self.end_offset.is_finite()
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ConicGradient {
+ pub center: LayoutPoint,
+ pub angle: f32,
+ pub start_offset: f32,
+ pub end_offset: f32,
+ pub extend_mode: ExtendMode,
+} // IMPLICIT stops: Vec<GradientStop>
+
+impl ConicGradient {
+ pub fn is_valid(&self) -> bool {
+ self.center.x.is_finite() &&
+ self.center.y.is_finite() &&
+ self.angle.is_finite() &&
+ self.start_offset.is_finite() &&
+ self.end_offset.is_finite()
+ }
+}
+
+/// Just an abstraction for bundling up a bunch of clips into a "super clip".
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ClipChainItem {
+ pub id: ClipChainId,
+ pub parent: Option<ClipChainId>,
+} // IMPLICIT clip_ids: Vec<ClipId>
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RadialGradientDisplayItem {
+ pub common: CommonItemProperties,
+ /// The area to tile the gradient over (first tile starts at origin of this rect)
+ // FIXME: this should ideally just be `tile_origin` here, with the clip_rect
+ // defining the bounds of the item. Needs non-trivial backend changes.
+ pub bounds: LayoutRect,
+ pub gradient: RadialGradient,
+ pub tile_size: LayoutSize,
+ pub tile_spacing: LayoutSize,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ConicGradientDisplayItem {
+ pub common: CommonItemProperties,
+ /// The area to tile the gradient over (first tile starts at origin of this rect)
+ // FIXME: this should ideally just be `tile_origin` here, with the clip_rect
+ // defining the bounds of the item. Needs non-trivial backend changes.
+ pub bounds: LayoutRect,
+ pub gradient: ConicGradient,
+ pub tile_size: LayoutSize,
+ pub tile_spacing: LayoutSize,
+}
+
+/// Renders a filtered region of its backdrop
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct BackdropFilterDisplayItem {
+ pub common: CommonItemProperties,
+}
+// IMPLICIT: filters: Vec<FilterOp>, filter_datas: Vec<FilterData>, filter_primitives: Vec<FilterPrimitive>
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ReferenceFrameDisplayListItem {
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ReferenceFrameDescriptor {
+ pub origin: LayoutPoint,
+ pub parent_spatial_id: SpatialId,
+ pub reference_frame: ReferenceFrame,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum ReferenceFrameKind {
+ /// A normal transform matrix, may contain perspective (the CSS transform property)
+ Transform {
+ /// Optionally marks the transform as only ever having a simple 2D scale or translation,
+ /// allowing for optimizations.
+ is_2d_scale_translation: bool,
+ /// Marks that the transform should be snapped. Used for transforms which animate in
+ /// response to scrolling, eg for zooming or dynamic toolbar fixed-positioning.
+ should_snap: bool,
+ /// Marks the transform being a part of the CSS stacking context that also has
+ /// a perspective. In this case, backface visibility takes this perspective into
+ /// account.
+ paired_with_perspective: bool,
+ },
+ /// A perspective transform, that optionally scrolls relative to a specific scroll node
+ Perspective {
+ scrolling_relative_to: Option<ExternalScrollId>,
+ }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum Rotation {
+ Degree0,
+ Degree90,
+ Degree180,
+ Degree270,
+}
+
+impl Rotation {
+ pub fn to_matrix(
+ &self,
+ size: LayoutSize,
+ ) -> LayoutTransform {
+ let (shift_center_to_origin, angle) = match self {
+ Rotation::Degree0 => {
+ (LayoutTransform::translation(-size.width / 2., -size.height / 2., 0.), Angle::degrees(0.))
+ },
+ Rotation::Degree90 => {
+ (LayoutTransform::translation(-size.height / 2., -size.width / 2., 0.), Angle::degrees(90.))
+ },
+ Rotation::Degree180 => {
+ (LayoutTransform::translation(-size.width / 2., -size.height / 2., 0.), Angle::degrees(180.))
+ },
+ Rotation::Degree270 => {
+ (LayoutTransform::translation(-size.height / 2., -size.width / 2., 0.), Angle::degrees(270.))
+ },
+ };
+ let shift_origin_to_center = LayoutTransform::translation(size.width / 2., size.height / 2., 0.);
+
+ shift_center_to_origin
+ .then(&LayoutTransform::rotation(0., 0., 1.0, angle))
+ .then(&shift_origin_to_center)
+ }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum ReferenceTransformBinding {
+ /// Standard reference frame which contains a precomputed transform.
+ Static {
+ binding: PropertyBinding<LayoutTransform>,
+ },
+ /// Computed reference frame which dynamically calculates the transform
+ /// based on the given parameters. The reference is the content size of
+ /// the parent iframe, which is affected by snapping.
+ ///
+ /// This is used when a transform depends on the layout size of an
+ /// element, otherwise the difference between the unsnapped size
+ /// used in the transform, and the snapped size calculated during scene
+ /// building can cause seaming.
+ Computed {
+ scale_from: Option<LayoutSize>,
+ vertical_flip: bool,
+ rotation: Rotation,
+ },
+}
+
+impl Default for ReferenceTransformBinding {
+ fn default() -> Self {
+ ReferenceTransformBinding::Static {
+ binding: Default::default(),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ReferenceFrame {
+ pub kind: ReferenceFrameKind,
+ pub transform_style: TransformStyle,
+ /// The transform matrix, either the perspective matrix or the transform
+ /// matrix.
+ pub transform: ReferenceTransformBinding,
+ pub id: SpatialId,
+ /// A unique (per-pipeline) key for this spatial that is stable across display lists.
+ pub key: SpatialTreeItemKey,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct PushStackingContextDisplayItem {
+ pub origin: LayoutPoint,
+ pub spatial_id: SpatialId,
+ pub prim_flags: PrimitiveFlags,
+ pub stacking_context: StackingContext,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct StackingContext {
+ pub transform_style: TransformStyle,
+ pub mix_blend_mode: MixBlendMode,
+ pub clip_chain_id: Option<ClipChainId>,
+ pub raster_space: RasterSpace,
+ pub flags: StackingContextFlags,
+}
+// IMPLICIT: filters: Vec<FilterOp>, filter_datas: Vec<FilterData>, filter_primitives: Vec<FilterPrimitive>
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+pub enum TransformStyle {
+ Flat = 0,
+ Preserve3D = 1,
+}
+
+/// Configure whether the contents of a stacking context
+/// should be rasterized in local space or screen space.
+/// Local space rasterized pictures are typically used
+/// when we want to cache the output, and performance is
+/// important. Note that this is a performance hint only,
+/// which WR may choose to ignore.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, MallocSizeOf, Serialize, PeekPoke)]
+#[repr(u8)]
+pub enum RasterSpace {
+ // Rasterize in local-space, applying supplied scale to primitives.
+ // Best performance, but lower quality.
+ Local(f32),
+
+ // Rasterize the picture in screen-space, including rotation / skew etc in
+ // the rasterized element. Best quality, but slower performance. Note that
+ // any stacking context with a perspective transform will be rasterized
+ // in local-space, even if this is set.
+ Screen,
+}
+
+impl RasterSpace {
+ pub fn local_scale(self) -> Option<f32> {
+ match self {
+ RasterSpace::Local(scale) => Some(scale),
+ RasterSpace::Screen => None,
+ }
+ }
+}
+
+impl Eq for RasterSpace {}
+
+impl Hash for RasterSpace {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ match self {
+ RasterSpace::Screen => {
+ 0.hash(state);
+ }
+ RasterSpace::Local(scale) => {
+ // Note: this is inconsistent with the Eq impl for -0.0 (don't care).
+ 1.hash(state);
+ scale.to_bits().hash(state);
+ }
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Deserialize, MallocSizeOf, Serialize, PeekPoke)]
+pub struct StackingContextFlags(u8);
+
+bitflags! {
+ impl StackingContextFlags: u8 {
+ /// If true, this stacking context is a blend container than contains
+ /// mix-blend-mode children (and should thus be isolated).
+ const IS_BLEND_CONTAINER = 1 << 0;
+ /// If true, this stacking context is a wrapper around a backdrop-filter (e.g. for
+ /// a clip-mask). This is needed to allow the correct selection of a backdrop root
+ /// since a clip-mask stacking context creates a parent surface.
+ const WRAPS_BACKDROP_FILTER = 1 << 1;
+ }
+}
+
+impl core::fmt::Debug for StackingContextFlags {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.is_empty() {
+ write!(f, "{:#x}", Self::empty().bits())
+ } else {
+ bitflags::parser::to_writer(self, f)
+ }
+ }
+}
+
+impl Default for StackingContextFlags {
+ fn default() -> Self {
+ StackingContextFlags::empty()
+ }
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum MixBlendMode {
+ Normal = 0,
+ Multiply = 1,
+ Screen = 2,
+ Overlay = 3,
+ Darken = 4,
+ Lighten = 5,
+ ColorDodge = 6,
+ ColorBurn = 7,
+ HardLight = 8,
+ SoftLight = 9,
+ Difference = 10,
+ Exclusion = 11,
+ Hue = 12,
+ Saturation = 13,
+ Color = 14,
+ Luminosity = 15,
+ PlusLighter = 16,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum ColorSpace {
+ Srgb,
+ LinearRgb,
+}
+
+/// Available composite operoations for the composite filter primitive
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum CompositeOperator {
+ Over,
+ In,
+ Atop,
+ Out,
+ Xor,
+ Lighter,
+ Arithmetic([f32; 4]),
+}
+
+impl CompositeOperator {
+ // This must stay in sync with the composite operator defines in cs_svg_filter.glsl
+ pub fn as_int(&self) -> u32 {
+ match self {
+ CompositeOperator::Over => 0,
+ CompositeOperator::In => 1,
+ CompositeOperator::Out => 2,
+ CompositeOperator::Atop => 3,
+ CompositeOperator::Xor => 4,
+ CompositeOperator::Lighter => 5,
+ CompositeOperator::Arithmetic(..) => 6,
+ }
+ }
+}
+
+/// An input to a SVG filter primitive.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum FilterPrimitiveInput {
+ /// The input is the original graphic that the filter is being applied to.
+ Original,
+ /// The input is the output of the previous filter primitive in the filter primitive chain.
+ Previous,
+ /// The input is the output of the filter primitive at the given index in the filter primitive chain.
+ OutputOfPrimitiveIndex(usize),
+}
+
+impl FilterPrimitiveInput {
+ /// Gets the index of the input.
+ /// Returns `None` if the source graphic is the input.
+ pub fn to_index(self, cur_index: usize) -> Option<usize> {
+ match self {
+ FilterPrimitiveInput::Previous if cur_index > 0 => Some(cur_index - 1),
+ FilterPrimitiveInput::OutputOfPrimitiveIndex(index) => Some(index),
+ _ => None,
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct BlendPrimitive {
+ pub input1: FilterPrimitiveInput,
+ pub input2: FilterPrimitiveInput,
+ pub mode: MixBlendMode,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct FloodPrimitive {
+ pub color: ColorF,
+}
+
+impl FloodPrimitive {
+ pub fn sanitize(&mut self) {
+ self.color.r = self.color.r.min(1.0).max(0.0);
+ self.color.g = self.color.g.min(1.0).max(0.0);
+ self.color.b = self.color.b.min(1.0).max(0.0);
+ self.color.a = self.color.a.min(1.0).max(0.0);
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct BlurPrimitive {
+ pub input: FilterPrimitiveInput,
+ pub width: f32,
+ pub height: f32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct OpacityPrimitive {
+ pub input: FilterPrimitiveInput,
+ pub opacity: f32,
+}
+
+impl OpacityPrimitive {
+ pub fn sanitize(&mut self) {
+ self.opacity = self.opacity.min(1.0).max(0.0);
+ }
+}
+
+/// cbindgen:derive-eq=false
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ColorMatrixPrimitive {
+ pub input: FilterPrimitiveInput,
+ pub matrix: [f32; 20],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct DropShadowPrimitive {
+ pub input: FilterPrimitiveInput,
+ pub shadow: Shadow,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ComponentTransferPrimitive {
+ pub input: FilterPrimitiveInput,
+ // Component transfer data is stored in FilterData.
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct IdentityPrimitive {
+ pub input: FilterPrimitiveInput,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct OffsetPrimitive {
+ pub input: FilterPrimitiveInput,
+ pub offset: LayoutVector2D,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct CompositePrimitive {
+ pub input1: FilterPrimitiveInput,
+ pub input2: FilterPrimitiveInput,
+ pub operator: CompositeOperator,
+}
+
+/// See: https://github.com/eqrion/cbindgen/issues/9
+/// cbindgen:derive-eq=false
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum FilterPrimitiveKind {
+ Identity(IdentityPrimitive),
+ Blend(BlendPrimitive),
+ Flood(FloodPrimitive),
+ Blur(BlurPrimitive),
+ // TODO: Support animated opacity?
+ Opacity(OpacityPrimitive),
+ /// cbindgen:derive-eq=false
+ ColorMatrix(ColorMatrixPrimitive),
+ DropShadow(DropShadowPrimitive),
+ ComponentTransfer(ComponentTransferPrimitive),
+ Offset(OffsetPrimitive),
+ Composite(CompositePrimitive),
+}
+
+impl Default for FilterPrimitiveKind {
+ fn default() -> Self {
+ FilterPrimitiveKind::Identity(IdentityPrimitive::default())
+ }
+}
+
+impl FilterPrimitiveKind {
+ pub fn sanitize(&mut self) {
+ match self {
+ FilterPrimitiveKind::Flood(flood) => flood.sanitize(),
+ FilterPrimitiveKind::Opacity(opacity) => opacity.sanitize(),
+
+ // No sanitization needed.
+ FilterPrimitiveKind::Identity(..) |
+ FilterPrimitiveKind::Blend(..) |
+ FilterPrimitiveKind::ColorMatrix(..) |
+ FilterPrimitiveKind::Offset(..) |
+ FilterPrimitiveKind::Composite(..) |
+ FilterPrimitiveKind::Blur(..) |
+ FilterPrimitiveKind::DropShadow(..) |
+ // Component transfer's filter data is sanitized separately.
+ FilterPrimitiveKind::ComponentTransfer(..) => {}
+ }
+ }
+}
+
+/// SVG Filter Primitive.
+/// See: https://github.com/eqrion/cbindgen/issues/9
+/// cbindgen:derive-eq=false
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct FilterPrimitive {
+ pub kind: FilterPrimitiveKind,
+ pub color_space: ColorSpace,
+}
+
+impl FilterPrimitive {
+ pub fn sanitize(&mut self) {
+ self.kind.sanitize();
+ }
+}
+
+/// CSS filter.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Deserialize, Serialize, PeekPoke)]
+pub enum FilterOp {
+ /// Filter that does no transformation of the colors, needed for
+ /// debug purposes only.
+ Identity,
+ Blur(f32, f32),
+ Brightness(f32),
+ Contrast(f32),
+ Grayscale(f32),
+ HueRotate(f32),
+ Invert(f32),
+ Opacity(PropertyBinding<f32>, f32),
+ Saturate(f32),
+ Sepia(f32),
+ DropShadow(Shadow),
+ ColorMatrix([f32; 20]),
+ SrgbToLinear,
+ LinearToSrgb,
+ ComponentTransfer,
+ Flood(ColorF),
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Deserialize, Serialize, PeekPoke)]
+pub enum ComponentTransferFuncType {
+ Identity = 0,
+ Table = 1,
+ Discrete = 2,
+ Linear = 3,
+ Gamma = 4,
+}
+
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+pub struct FilterData {
+ pub func_r_type: ComponentTransferFuncType,
+ pub r_values: Vec<f32>,
+ pub func_g_type: ComponentTransferFuncType,
+ pub g_values: Vec<f32>,
+ pub func_b_type: ComponentTransferFuncType,
+ pub b_values: Vec<f32>,
+ pub func_a_type: ComponentTransferFuncType,
+ pub a_values: Vec<f32>,
+}
+
+fn sanitize_func_type(
+ func_type: ComponentTransferFuncType,
+ values: &[f32],
+) -> ComponentTransferFuncType {
+ if values.is_empty() {
+ return ComponentTransferFuncType::Identity;
+ }
+ if values.len() < 2 && func_type == ComponentTransferFuncType::Linear {
+ return ComponentTransferFuncType::Identity;
+ }
+ if values.len() < 3 && func_type == ComponentTransferFuncType::Gamma {
+ return ComponentTransferFuncType::Identity;
+ }
+ func_type
+}
+
+fn sanitize_values(
+ func_type: ComponentTransferFuncType,
+ values: &[f32],
+) -> bool {
+ if values.len() < 2 && func_type == ComponentTransferFuncType::Linear {
+ return false;
+ }
+ if values.len() < 3 && func_type == ComponentTransferFuncType::Gamma {
+ return false;
+ }
+ true
+}
+
+impl FilterData {
+ /// Ensure that the number of values matches up with the function type.
+ pub fn sanitize(&self) -> FilterData {
+ FilterData {
+ func_r_type: sanitize_func_type(self.func_r_type, &self.r_values),
+ r_values:
+ if sanitize_values(self.func_r_type, &self.r_values) {
+ self.r_values.clone()
+ } else {
+ Vec::new()
+ },
+ func_g_type: sanitize_func_type(self.func_g_type, &self.g_values),
+ g_values:
+ if sanitize_values(self.func_g_type, &self.g_values) {
+ self.g_values.clone()
+ } else {
+ Vec::new()
+ },
+
+ func_b_type: sanitize_func_type(self.func_b_type, &self.b_values),
+ b_values:
+ if sanitize_values(self.func_b_type, &self.b_values) {
+ self.b_values.clone()
+ } else {
+ Vec::new()
+ },
+
+ func_a_type: sanitize_func_type(self.func_a_type, &self.a_values),
+ a_values:
+ if sanitize_values(self.func_a_type, &self.a_values) {
+ self.a_values.clone()
+ } else {
+ Vec::new()
+ },
+
+ }
+ }
+
+ pub fn is_identity(&self) -> bool {
+ self.func_r_type == ComponentTransferFuncType::Identity &&
+ self.func_g_type == ComponentTransferFuncType::Identity &&
+ self.func_b_type == ComponentTransferFuncType::Identity &&
+ self.func_a_type == ComponentTransferFuncType::Identity
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct IframeDisplayItem {
+ pub bounds: LayoutRect,
+ pub clip_rect: LayoutRect,
+ pub space_and_clip: SpaceAndClipInfo,
+ pub pipeline_id: PipelineId,
+ pub ignore_missing_pipeline: bool,
+}
+
+/// This describes an image that fills the specified area. It stretches or shrinks
+/// the image as necessary. While RepeatingImageDisplayItem could otherwise provide
+/// a superset of the functionality, it has been problematic inferring the desired
+/// repetition properties when snapping changes the size of the primitive.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ImageDisplayItem {
+ pub common: CommonItemProperties,
+ /// The area to tile the image over (first tile starts at origin of this rect)
+ // FIXME: this should ideally just be `tile_origin` here, with the clip_rect
+ // defining the bounds of the item. Needs non-trivial backend changes.
+ pub bounds: LayoutRect,
+ pub image_key: ImageKey,
+ pub image_rendering: ImageRendering,
+ pub alpha_type: AlphaType,
+ /// A hack used by gecko to color a simple bitmap font used for tofu glyphs
+ pub color: ColorF,
+}
+
+/// This describes a background-image and its tiling. It repeats in a grid to fill
+/// the specified area.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct RepeatingImageDisplayItem {
+ pub common: CommonItemProperties,
+ /// The area to tile the image over (first tile starts at origin of this rect)
+ // FIXME: this should ideally just be `tile_origin` here, with the clip_rect
+ // defining the bounds of the item. Needs non-trivial backend changes.
+ pub bounds: LayoutRect,
+ /// How large to make a single tile of the image (common case: bounds.size)
+ pub stretch_size: LayoutSize,
+ /// The space between tiles (common case: 0)
+ pub tile_spacing: LayoutSize,
+ pub image_key: ImageKey,
+ pub image_rendering: ImageRendering,
+ pub alpha_type: AlphaType,
+ /// A hack used by gecko to color a simple bitmap font used for tofu glyphs
+ pub color: ColorF,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum ImageRendering {
+ Auto = 0,
+ CrispEdges = 1,
+ Pixelated = 2,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum AlphaType {
+ Alpha = 0,
+ PremultipliedAlpha = 1,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct YuvImageDisplayItem {
+ pub common: CommonItemProperties,
+ pub bounds: LayoutRect,
+ pub yuv_data: YuvData,
+ pub color_depth: ColorDepth,
+ pub color_space: YuvColorSpace,
+ pub color_range: ColorRange,
+ pub image_rendering: ImageRendering,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum YuvColorSpace {
+ Rec601 = 0,
+ Rec709 = 1,
+ Rec2020 = 2,
+ Identity = 3, // aka GBR as per ISO/IEC 23091-2:2019
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum ColorRange {
+ Limited = 0,
+ Full = 1,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum YuvRangedColorSpace {
+ Rec601Narrow = 0,
+ Rec601Full = 1,
+ Rec709Narrow = 2,
+ Rec709Full = 3,
+ Rec2020Narrow = 4,
+ Rec2020Full = 5,
+ GbrIdentity = 6,
+}
+
+impl YuvColorSpace {
+ pub fn with_range(self, range: ColorRange) -> YuvRangedColorSpace {
+ match self {
+ YuvColorSpace::Identity => YuvRangedColorSpace::GbrIdentity,
+ YuvColorSpace::Rec601 => {
+ match range {
+ ColorRange::Limited => YuvRangedColorSpace::Rec601Narrow,
+ ColorRange::Full => YuvRangedColorSpace::Rec601Full,
+ }
+ }
+ YuvColorSpace::Rec709 => {
+ match range {
+ ColorRange::Limited => YuvRangedColorSpace::Rec709Narrow,
+ ColorRange::Full => YuvRangedColorSpace::Rec709Full,
+ }
+ }
+ YuvColorSpace::Rec2020 => {
+ match range {
+ ColorRange::Limited => YuvRangedColorSpace::Rec2020Narrow,
+ ColorRange::Full => YuvRangedColorSpace::Rec2020Full,
+ }
+ }
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+pub enum YuvData {
+ NV12(ImageKey, ImageKey), // (Y channel, CbCr interleaved channel)
+ P010(ImageKey, ImageKey), // (Y channel, CbCr interleaved channel)
+ PlanarYCbCr(ImageKey, ImageKey, ImageKey), // (Y channel, Cb channel, Cr Channel)
+ InterleavedYCbCr(ImageKey), // (YCbCr interleaved channel)
+}
+
+impl YuvData {
+ pub fn get_format(&self) -> YuvFormat {
+ match *self {
+ YuvData::NV12(..) => YuvFormat::NV12,
+ YuvData::P010(..) => YuvFormat::P010,
+ YuvData::PlanarYCbCr(..) => YuvFormat::PlanarYCbCr,
+ YuvData::InterleavedYCbCr(..) => YuvFormat::InterleavedYCbCr,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum YuvFormat {
+ NV12 = 0,
+ P010 = 1,
+ PlanarYCbCr = 2,
+ InterleavedYCbCr = 3,
+}
+
+impl YuvFormat {
+ pub fn get_plane_num(self) -> usize {
+ match self {
+ YuvFormat::NV12 | YuvFormat::P010 => 2,
+ YuvFormat::PlanarYCbCr => 3,
+ YuvFormat::InterleavedYCbCr => 1,
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ImageMask {
+ pub image: ImageKey,
+ pub rect: LayoutRect,
+}
+
+impl ImageMask {
+ /// Get a local clipping rect contributed by this mask.
+ pub fn get_local_clip_rect(&self) -> Option<LayoutRect> {
+ Some(self.rect)
+ }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, MallocSizeOf, PartialEq, Serialize, Deserialize, Eq, Hash, PeekPoke)]
+pub enum ClipMode {
+ Clip, // Pixels inside the region are visible.
+ ClipOut, // Pixels outside the region are visible.
+}
+
+impl Not for ClipMode {
+ type Output = ClipMode;
+
+ fn not(self) -> ClipMode {
+ match self {
+ ClipMode::Clip => ClipMode::ClipOut,
+ ClipMode::ClipOut => ClipMode::Clip,
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub struct ComplexClipRegion {
+ /// The boundaries of the rectangle.
+ pub rect: LayoutRect,
+ /// Border radii of this rectangle.
+ pub radii: BorderRadius,
+ /// Whether we are clipping inside or outside
+ /// the region.
+ pub mode: ClipMode,
+}
+
+impl BorderRadius {
+ pub fn zero() -> BorderRadius {
+ BorderRadius {
+ top_left: LayoutSize::new(0.0, 0.0),
+ top_right: LayoutSize::new(0.0, 0.0),
+ bottom_left: LayoutSize::new(0.0, 0.0),
+ bottom_right: LayoutSize::new(0.0, 0.0),
+ }
+ }
+
+ pub fn uniform(radius: f32) -> BorderRadius {
+ BorderRadius {
+ top_left: LayoutSize::new(radius, radius),
+ top_right: LayoutSize::new(radius, radius),
+ bottom_left: LayoutSize::new(radius, radius),
+ bottom_right: LayoutSize::new(radius, radius),
+ }
+ }
+
+ pub fn uniform_size(radius: LayoutSize) -> BorderRadius {
+ BorderRadius {
+ top_left: radius,
+ top_right: radius,
+ bottom_left: radius,
+ bottom_right: radius,
+ }
+ }
+
+ pub fn is_uniform(&self) -> Option<f32> {
+ match self.is_uniform_size() {
+ Some(radius) if radius.width == radius.height => Some(radius.width),
+ _ => None,
+ }
+ }
+
+ pub fn is_uniform_size(&self) -> Option<LayoutSize> {
+ let uniform_radius = self.top_left;
+ if self.top_right == uniform_radius && self.bottom_left == uniform_radius &&
+ self.bottom_right == uniform_radius
+ {
+ Some(uniform_radius)
+ } else {
+ None
+ }
+ }
+
+ /// Return whether, in each corner, the radius in *either* direction is zero.
+ /// This means that none of the corners are rounded.
+ pub fn is_zero(&self) -> bool {
+ let corner_is_zero = |corner: &LayoutSize| corner.width == 0.0 || corner.height == 0.0;
+ corner_is_zero(&self.top_left) &&
+ corner_is_zero(&self.top_right) &&
+ corner_is_zero(&self.bottom_right) &&
+ corner_is_zero(&self.bottom_left)
+ }
+}
+
+impl ComplexClipRegion {
+ /// Create a new complex clip region.
+ pub fn new(
+ rect: LayoutRect,
+ radii: BorderRadius,
+ mode: ClipMode,
+ ) -> Self {
+ ComplexClipRegion { rect, radii, mode }
+ }
+}
+
+impl ComplexClipRegion {
+ /// Get a local clipping rect contributed by this clip region.
+ pub fn get_local_clip_rect(&self) -> Option<LayoutRect> {
+ match self.mode {
+ ClipMode::Clip => {
+ Some(self.rect)
+ }
+ ClipMode::ClipOut => {
+ None
+ }
+ }
+ }
+}
+
+pub const POLYGON_CLIP_VERTEX_MAX: usize = 32;
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, Eq, Hash, PeekPoke)]
+pub enum FillRule {
+ Nonzero = 0x1, // Behaves as the SVG fill-rule definition for nonzero.
+ Evenodd = 0x2, // Behaves as the SVG fill-rule definition for evenodd.
+}
+
+impl From<u8> for FillRule {
+ fn from(fill_rule: u8) -> Self {
+ match fill_rule {
+ 0x1 => FillRule::Nonzero,
+ 0x2 => FillRule::Evenodd,
+ _ => panic!("Unexpected FillRule value."),
+ }
+ }
+}
+
+impl From<FillRule> for u8 {
+ fn from(fill_rule: FillRule) -> Self {
+ match fill_rule {
+ FillRule::Nonzero => 0x1,
+ FillRule::Evenodd => 0x2,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+pub struct ClipChainId(pub u64, pub PipelineId);
+
+impl ClipChainId {
+ pub const INVALID: Self = ClipChainId(!0, PipelineId::INVALID);
+}
+
+/// A reference to a clipping node defining how an item is clipped.
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+pub struct ClipId(pub usize, pub PipelineId);
+
+impl Default for ClipId {
+ fn default() -> Self {
+ ClipId::invalid()
+ }
+}
+
+const ROOT_CLIP_ID: usize = 0;
+
+impl ClipId {
+ /// Return the root clip ID - effectively doing no clipping.
+ pub fn root(pipeline_id: PipelineId) -> Self {
+ ClipId(ROOT_CLIP_ID, pipeline_id)
+ }
+
+ /// Return an invalid clip ID - needed in places where we carry
+ /// one but need to not attempt to use it.
+ pub fn invalid() -> Self {
+ ClipId(!0, PipelineId::dummy())
+ }
+
+ pub fn pipeline_id(&self) -> PipelineId {
+ match *self {
+ ClipId(_, pipeline_id) => pipeline_id,
+ }
+ }
+
+ pub fn is_root(&self) -> bool {
+ match *self {
+ ClipId(id, _) => id == ROOT_CLIP_ID,
+ }
+ }
+
+ pub fn is_valid(&self) -> bool {
+ match *self {
+ ClipId(id, _) => id != !0,
+ }
+ }
+}
+
+/// A reference to a spatial node defining item positioning.
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+pub struct SpatialId(pub usize, PipelineId);
+
+const ROOT_REFERENCE_FRAME_SPATIAL_ID: usize = 0;
+const ROOT_SCROLL_NODE_SPATIAL_ID: usize = 1;
+
+impl SpatialId {
+ pub fn new(spatial_node_index: usize, pipeline_id: PipelineId) -> Self {
+ SpatialId(spatial_node_index, pipeline_id)
+ }
+
+ pub fn root_reference_frame(pipeline_id: PipelineId) -> Self {
+ SpatialId(ROOT_REFERENCE_FRAME_SPATIAL_ID, pipeline_id)
+ }
+
+ pub fn root_scroll_node(pipeline_id: PipelineId) -> Self {
+ SpatialId(ROOT_SCROLL_NODE_SPATIAL_ID, pipeline_id)
+ }
+
+ pub fn pipeline_id(&self) -> PipelineId {
+ self.1
+ }
+}
+
+/// An external identifier that uniquely identifies a scroll frame independent of its ClipId, which
+/// may change from frame to frame. This should be unique within a pipeline. WebRender makes no
+/// attempt to ensure uniqueness. The zero value is reserved for use by the root scroll node of
+/// every pipeline, which always has an external id.
+///
+/// When setting display lists with the `preserve_frame_state` this id is used to preserve scroll
+/// offsets between different sets of SpatialNodes which are ScrollFrames.
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, Hash, PartialEq, Serialize, PeekPoke)]
+#[repr(C)]
+pub struct ExternalScrollId(pub u64, pub PipelineId);
+
+impl ExternalScrollId {
+ pub fn pipeline_id(&self) -> PipelineId {
+ self.1
+ }
+
+ pub fn is_root(&self) -> bool {
+ self.0 == 0
+ }
+}
+
+impl DisplayItem {
+ pub fn debug_name(&self) -> &'static str {
+ match *self {
+ DisplayItem::Border(..) => "border",
+ DisplayItem::BoxShadow(..) => "box_shadow",
+ DisplayItem::ClearRectangle(..) => "clear_rectangle",
+ DisplayItem::HitTest(..) => "hit_test",
+ DisplayItem::RectClip(..) => "rect_clip",
+ DisplayItem::RoundedRectClip(..) => "rounded_rect_clip",
+ DisplayItem::ImageMaskClip(..) => "image_mask_clip",
+ DisplayItem::ClipChain(..) => "clip_chain",
+ DisplayItem::ConicGradient(..) => "conic_gradient",
+ DisplayItem::Gradient(..) => "gradient",
+ DisplayItem::Iframe(..) => "iframe",
+ DisplayItem::Image(..) => "image",
+ DisplayItem::RepeatingImage(..) => "repeating_image",
+ DisplayItem::Line(..) => "line",
+ DisplayItem::PopAllShadows => "pop_all_shadows",
+ DisplayItem::PopReferenceFrame => "pop_reference_frame",
+ DisplayItem::PopStackingContext => "pop_stacking_context",
+ DisplayItem::PushShadow(..) => "push_shadow",
+ DisplayItem::PushReferenceFrame(..) => "push_reference_frame",
+ DisplayItem::PushStackingContext(..) => "push_stacking_context",
+ DisplayItem::SetFilterOps => "set_filter_ops",
+ DisplayItem::SetFilterData => "set_filter_data",
+ DisplayItem::SetFilterPrimitives => "set_filter_primitives",
+ DisplayItem::SetPoints => "set_points",
+ DisplayItem::RadialGradient(..) => "radial_gradient",
+ DisplayItem::Rectangle(..) => "rectangle",
+ DisplayItem::SetGradientStops => "set_gradient_stops",
+ DisplayItem::ReuseItems(..) => "reuse_item",
+ DisplayItem::RetainedItems(..) => "retained_items",
+ DisplayItem::Text(..) => "text",
+ DisplayItem::YuvImage(..) => "yuv_image",
+ DisplayItem::BackdropFilter(..) => "backdrop_filter",
+ }
+ }
+}
+
+macro_rules! impl_default_for_enums {
+ ($($enum:ident => $init:expr ),+) => {
+ $(impl Default for $enum {
+ #[allow(unused_imports)]
+ fn default() -> Self {
+ use $enum::*;
+ $init
+ }
+ })*
+ }
+}
+
+impl_default_for_enums! {
+ DisplayItem => PopStackingContext,
+ LineOrientation => Vertical,
+ LineStyle => Solid,
+ RepeatMode => Stretch,
+ NinePatchBorderSource => Image(ImageKey::default(), ImageRendering::Auto),
+ BorderDetails => Normal(NormalBorder::default()),
+ BorderRadiusKind => Uniform,
+ BorderStyle => None,
+ BoxShadowClipMode => Outset,
+ ExtendMode => Clamp,
+ FilterOp => Identity,
+ ComponentTransferFuncType => Identity,
+ ClipMode => Clip,
+ FillRule => Nonzero,
+ ReferenceFrameKind => Transform {
+ is_2d_scale_translation: false,
+ should_snap: false,
+ paired_with_perspective: false,
+ },
+ Rotation => Degree0,
+ TransformStyle => Flat,
+ RasterSpace => Local(f32::default()),
+ MixBlendMode => Normal,
+ ImageRendering => Auto,
+ AlphaType => Alpha,
+ YuvColorSpace => Rec601,
+ YuvRangedColorSpace => Rec601Narrow,
+ ColorRange => Limited,
+ YuvData => NV12(ImageKey::default(), ImageKey::default()),
+ YuvFormat => NV12,
+ FilterPrimitiveInput => Original,
+ ColorSpace => Srgb,
+ CompositeOperator => Over
+}
diff --git a/gfx/wr/webrender_api/src/display_item_cache.rs b/gfx/wr/webrender_api/src/display_item_cache.rs
new file mode 100644
index 0000000000..60d41c591d
--- /dev/null
+++ b/gfx/wr/webrender_api/src/display_item_cache.rs
@@ -0,0 +1,115 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use crate::display_item::*;
+use crate::display_list::*;
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct CachedDisplayItem {
+ item: DisplayItem,
+ data: Vec<u8>,
+}
+
+impl CachedDisplayItem {
+ pub fn display_item(&self) -> &DisplayItem {
+ &self.item
+ }
+
+ pub fn data_as_item_range<T>(&self) -> ItemRange<T> {
+ ItemRange::new(&self.data)
+ }
+}
+
+impl MallocSizeOf for CachedDisplayItem {
+ fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+ self.data.size_of(ops)
+ }
+}
+
+impl From<DisplayItemRef<'_, '_>> for CachedDisplayItem {
+ fn from(item_ref: DisplayItemRef) -> Self {
+ let item = item_ref.item();
+
+ match item {
+ DisplayItem::Text(..) => CachedDisplayItem {
+ item: *item,
+ data: item_ref.glyphs().bytes().to_vec(),
+ },
+ _ => CachedDisplayItem {
+ item: *item,
+ data: Vec::new(),
+ },
+ }
+ }
+}
+
+#[derive(Clone, Deserialize, MallocSizeOf, Serialize)]
+struct CacheEntry {
+ items: Vec<CachedDisplayItem>,
+ occupied: bool,
+}
+
+#[derive(Clone, Deserialize, MallocSizeOf, Serialize)]
+pub struct DisplayItemCache {
+ entries: Vec<CacheEntry>,
+}
+
+impl DisplayItemCache {
+ fn add_item(&mut self, key: ItemKey, item: CachedDisplayItem) {
+ let entry = &mut self.entries[key as usize];
+ entry.items.push(item);
+ entry.occupied = true;
+ }
+
+ fn clear_entry(&mut self, key: ItemKey) {
+ let entry = &mut self.entries[key as usize];
+ entry.items.clear();
+ entry.occupied = false;
+ }
+
+ fn grow_if_needed(&mut self, capacity: usize) {
+ if capacity > self.entries.len() {
+ self.entries.resize_with(capacity, || CacheEntry {
+ items: Vec::new(),
+ occupied: false,
+ });
+ }
+ }
+
+ pub fn get_items(&self, key: ItemKey) -> &[CachedDisplayItem] {
+ let entry = &self.entries[key as usize];
+ debug_assert!(entry.occupied);
+ entry.items.as_slice()
+ }
+
+ pub fn new() -> Self {
+ Self {
+ entries: Vec::new(),
+ }
+ }
+
+ pub fn update(&mut self, display_list: &BuiltDisplayList) {
+ self.grow_if_needed(display_list.cache_size());
+
+ let mut iter = display_list.cache_data_iter();
+ let mut current_key: Option<ItemKey> = None;
+ loop {
+ let item = match iter.next() {
+ Some(item) => item,
+ None => break,
+ };
+
+ if let DisplayItem::RetainedItems(key) = item.item() {
+ current_key = Some(*key);
+ self.clear_entry(*key);
+ continue;
+ }
+
+ let key = current_key.expect("Missing RetainedItems marker");
+ let cached_item = CachedDisplayItem::from(item);
+ self.add_item(key, cached_item);
+ }
+ }
+}
diff --git a/gfx/wr/webrender_api/src/display_list.rs b/gfx/wr/webrender_api/src/display_list.rs
new file mode 100644
index 0000000000..f1eea85ca3
--- /dev/null
+++ b/gfx/wr/webrender_api/src/display_list.rs
@@ -0,0 +1,2338 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use euclid::SideOffsets2D;
+use peek_poke::{ensure_red_zone, peek_from_slice, poke_extend_vec, strip_red_zone};
+use peek_poke::{poke_inplace_slice, poke_into_vec, Poke};
+#[cfg(feature = "deserialize")]
+use serde::de::Deserializer;
+#[cfg(feature = "serialize")]
+use serde::ser::Serializer;
+use serde::{Deserialize, Serialize};
+use std::io::Write;
+use std::marker::PhantomData;
+use std::ops::Range;
+use std::mem;
+use std::collections::HashMap;
+use time::precise_time_ns;
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+// local imports
+use crate::display_item as di;
+use crate::display_item_cache::*;
+use crate::{APZScrollGeneration, HasScrollLinkedEffect, PipelineId, PropertyBinding};
+use crate::gradient_builder::GradientBuilder;
+use crate::color::ColorF;
+use crate::font::{FontInstanceKey, GlyphInstance, GlyphOptions};
+use crate::image::{ColorDepth, ImageKey};
+use crate::units::*;
+
+
+// We don't want to push a long text-run. If a text-run is too long, split it into several parts.
+// This needs to be set to (renderer::MAX_VERTEX_TEXTURE_WIDTH - VECS_PER_TEXT_RUN) * 2
+pub const MAX_TEXT_RUN_LENGTH: usize = 2040;
+
+// See ROOT_REFERENCE_FRAME_SPATIAL_ID and ROOT_SCROLL_NODE_SPATIAL_ID
+// TODO(mrobinson): It would be a good idea to eliminate the root scroll frame which is only
+// used by Servo.
+const FIRST_SPATIAL_NODE_INDEX: usize = 2;
+
+// See ROOT_SCROLL_NODE_SPATIAL_ID
+const FIRST_CLIP_NODE_INDEX: usize = 1;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+enum BuildState {
+ Idle,
+ Build,
+}
+
+#[repr(C)]
+#[derive(Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub struct ItemRange<'a, T> {
+ bytes: &'a [u8],
+ _boo: PhantomData<T>,
+}
+
+impl<'a, T> Copy for ItemRange<'a, T> {}
+impl<'a, T> Clone for ItemRange<'a, T> {
+ fn clone(&self) -> Self {
+ *self
+ }
+}
+
+impl<'a, T> Default for ItemRange<'a, T> {
+ fn default() -> Self {
+ ItemRange {
+ bytes: Default::default(),
+ _boo: PhantomData,
+ }
+ }
+}
+
+impl<'a, T> ItemRange<'a, T> {
+ pub fn new(bytes: &'a [u8]) -> Self {
+ Self {
+ bytes,
+ _boo: PhantomData
+ }
+ }
+
+ pub fn is_empty(&self) -> bool {
+ // Nothing more than space for a length (0).
+ self.bytes.len() <= mem::size_of::<usize>()
+ }
+
+ pub fn bytes(&self) -> &[u8] {
+ &self.bytes
+ }
+}
+
+impl<'a, T: Default> ItemRange<'a, T> {
+ pub fn iter(&self) -> AuxIter<'a, T> {
+ AuxIter::new(T::default(), self.bytes)
+ }
+}
+
+impl<'a, T> IntoIterator for ItemRange<'a, T>
+where
+ T: Copy + Default + peek_poke::Peek,
+{
+ type Item = T;
+ type IntoIter = AuxIter<'a, T>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+#[derive(Copy, Clone)]
+pub struct TempFilterData<'a> {
+ pub func_types: ItemRange<'a, di::ComponentTransferFuncType>,
+ pub r_values: ItemRange<'a, f32>,
+ pub g_values: ItemRange<'a, f32>,
+ pub b_values: ItemRange<'a, f32>,
+ pub a_values: ItemRange<'a, f32>,
+}
+
+#[derive(Default, Clone)]
+pub struct DisplayListPayload {
+ /// Serde encoded bytes. Mostly DisplayItems, but some mixed in slices.
+ pub items_data: Vec<u8>,
+
+ /// Serde encoded DisplayItemCache structs
+ pub cache_data: Vec<u8>,
+
+ /// Serde encoded SpatialTreeItem structs
+ pub spatial_tree: Vec<u8>,
+}
+
+impl DisplayListPayload {
+ fn default() -> Self {
+ DisplayListPayload {
+ items_data: Vec::new(),
+ cache_data: Vec::new(),
+ spatial_tree: Vec::new(),
+ }
+ }
+
+ fn new(capacity: DisplayListCapacity) -> Self {
+ let mut payload = Self::default();
+
+ // We can safely ignore the preallocations failing, since we aren't
+ // certain about how much memory we need, and this gives a chance for
+ // the memory pressure events to run.
+ if let Err(_) = payload.items_data.try_reserve(capacity.items_size) {
+ return Self::default();
+ }
+ if let Err(_) = payload.cache_data.try_reserve(capacity.cache_size) {
+ return Self::default();
+ }
+ if let Err(_) = payload.spatial_tree.try_reserve(capacity.spatial_tree_size) {
+ return Self::default();
+ }
+ payload
+ }
+
+ fn clear(&mut self) {
+ self.items_data.clear();
+ self.cache_data.clear();
+ self.spatial_tree.clear();
+ }
+
+ fn size_in_bytes(&self) -> usize {
+ self.items_data.len() +
+ self.cache_data.len() +
+ self.spatial_tree.len()
+ }
+
+ #[cfg(feature = "serialize")]
+ fn create_debug_spatial_tree_items(&self) -> Vec<di::SpatialTreeItem> {
+ let mut items = Vec::new();
+
+ iter_spatial_tree(&self.spatial_tree, |item| {
+ items.push(*item);
+ });
+
+ items
+ }
+}
+
+impl MallocSizeOf for DisplayListPayload {
+ fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+ self.items_data.size_of(ops) +
+ self.cache_data.size_of(ops) +
+ self.spatial_tree.size_of(ops)
+ }
+}
+
+/// A display list.
+#[derive(Default, Clone)]
+pub struct BuiltDisplayList {
+ payload: DisplayListPayload,
+ descriptor: BuiltDisplayListDescriptor,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Deserialize, Serialize)]
+pub enum GeckoDisplayListType {
+ None,
+ Partial(f64),
+ Full(f64),
+}
+
+impl Default for GeckoDisplayListType {
+ fn default() -> Self { GeckoDisplayListType::None }
+}
+
+/// Describes the memory layout of a display list.
+///
+/// A display list consists of some number of display list items, followed by a number of display
+/// items.
+#[repr(C)]
+#[derive(Copy, Clone, Default, Deserialize, Serialize)]
+pub struct BuiltDisplayListDescriptor {
+ /// Gecko specific information about the display list.
+ gecko_display_list_type: GeckoDisplayListType,
+ /// The first IPC time stamp: before any work has been done
+ builder_start_time: u64,
+ /// The second IPC time stamp: after serialization
+ builder_finish_time: u64,
+ /// The third IPC time stamp: just before sending
+ send_start_time: u64,
+ /// The amount of clipping nodes created while building this display list.
+ total_clip_nodes: usize,
+ /// The amount of spatial nodes created while building this display list.
+ total_spatial_nodes: usize,
+ /// The size of the cache for this display list.
+ cache_size: usize,
+}
+
+#[derive(Clone)]
+pub struct DisplayListWithCache {
+ pub display_list: BuiltDisplayList,
+ cache: DisplayItemCache,
+}
+
+impl DisplayListWithCache {
+ pub fn iter(&self) -> BuiltDisplayListIter {
+ self.display_list.iter_with_cache(&self.cache)
+ }
+
+ pub fn new_from_list(display_list: BuiltDisplayList) -> Self {
+ let mut cache = DisplayItemCache::new();
+ cache.update(&display_list);
+
+ DisplayListWithCache {
+ display_list,
+ cache
+ }
+ }
+
+ pub fn update(&mut self, display_list: BuiltDisplayList) {
+ self.cache.update(&display_list);
+ self.display_list = display_list;
+ }
+
+ pub fn descriptor(&self) -> &BuiltDisplayListDescriptor {
+ self.display_list.descriptor()
+ }
+
+ pub fn times(&self) -> (u64, u64, u64) {
+ self.display_list.times()
+ }
+
+ pub fn items_data(&self) -> &[u8] {
+ self.display_list.items_data()
+ }
+}
+
+impl MallocSizeOf for DisplayListWithCache {
+ fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+ self.display_list.payload.size_of(ops) + self.cache.size_of(ops)
+ }
+}
+
+/// A debug (human-readable) representation of a built display list that
+/// can be used for capture and replay.
+#[cfg(any(feature = "serialize", feature = "deserialize"))]
+#[cfg_attr(feature = "serialize", derive(Serialize))]
+#[cfg_attr(feature = "deserialize", derive(Deserialize))]
+struct DisplayListCapture {
+ display_items: Vec<di::DebugDisplayItem>,
+ spatial_tree_items: Vec<di::SpatialTreeItem>,
+ descriptor: BuiltDisplayListDescriptor,
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for DisplayListWithCache {
+ fn serialize<S: Serializer>(
+ &self,
+ serializer: S
+ ) -> Result<S::Ok, S::Error> {
+ let display_items = BuiltDisplayList::create_debug_display_items(self.iter());
+ let spatial_tree_items = self.display_list.payload.create_debug_spatial_tree_items();
+
+ let dl = DisplayListCapture {
+ display_items,
+ spatial_tree_items,
+ descriptor: self.display_list.descriptor,
+ };
+
+ dl.serialize(serializer)
+ }
+}
+
+#[cfg(feature = "deserialize")]
+impl<'de> Deserialize<'de> for DisplayListWithCache {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ use crate::display_item::DisplayItem as Real;
+ use crate::display_item::DebugDisplayItem as Debug;
+
+ let capture = DisplayListCapture::deserialize(deserializer)?;
+
+ let mut spatial_tree = Vec::new();
+ for item in capture.spatial_tree_items {
+ poke_into_vec(&item, &mut spatial_tree);
+ }
+ ensure_red_zone::<di::SpatialTreeItem>(&mut spatial_tree);
+
+ let mut items_data = Vec::new();
+ let mut temp = Vec::new();
+ for complete in capture.display_items {
+ let item = match complete {
+ Debug::ClipChain(v, clip_chain_ids) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, clip_chain_ids);
+ Real::ClipChain(v)
+ }
+ Debug::Text(v, glyphs) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, glyphs);
+ Real::Text(v)
+ },
+ Debug::Iframe(v) => {
+ Real::Iframe(v)
+ }
+ Debug::PushReferenceFrame(v) => {
+ Real::PushReferenceFrame(v)
+ }
+ Debug::SetFilterOps(filters) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, filters);
+ Real::SetFilterOps
+ },
+ Debug::SetFilterData(filter_data) => {
+ let func_types: Vec<di::ComponentTransferFuncType> =
+ [filter_data.func_r_type,
+ filter_data.func_g_type,
+ filter_data.func_b_type,
+ filter_data.func_a_type].to_vec();
+ DisplayListBuilder::push_iter_impl(&mut temp, func_types);
+ DisplayListBuilder::push_iter_impl(&mut temp, filter_data.r_values);
+ DisplayListBuilder::push_iter_impl(&mut temp, filter_data.g_values);
+ DisplayListBuilder::push_iter_impl(&mut temp, filter_data.b_values);
+ DisplayListBuilder::push_iter_impl(&mut temp, filter_data.a_values);
+ Real::SetFilterData
+ },
+ Debug::SetFilterPrimitives(filter_primitives) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, filter_primitives);
+ Real::SetFilterPrimitives
+ }
+ Debug::SetGradientStops(stops) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, stops);
+ Real::SetGradientStops
+ },
+ Debug::SetPoints(points) => {
+ DisplayListBuilder::push_iter_impl(&mut temp, points);
+ Real::SetPoints
+ },
+ Debug::RectClip(v) => Real::RectClip(v),
+ Debug::RoundedRectClip(v) => Real::RoundedRectClip(v),
+ Debug::ImageMaskClip(v) => Real::ImageMaskClip(v),
+ Debug::Rectangle(v) => Real::Rectangle(v),
+ Debug::ClearRectangle(v) => Real::ClearRectangle(v),
+ Debug::HitTest(v) => Real::HitTest(v),
+ Debug::Line(v) => Real::Line(v),
+ Debug::Image(v) => Real::Image(v),
+ Debug::RepeatingImage(v) => Real::RepeatingImage(v),
+ Debug::YuvImage(v) => Real::YuvImage(v),
+ Debug::Border(v) => Real::Border(v),
+ Debug::BoxShadow(v) => Real::BoxShadow(v),
+ Debug::Gradient(v) => Real::Gradient(v),
+ Debug::RadialGradient(v) => Real::RadialGradient(v),
+ Debug::ConicGradient(v) => Real::ConicGradient(v),
+ Debug::PushStackingContext(v) => Real::PushStackingContext(v),
+ Debug::PushShadow(v) => Real::PushShadow(v),
+ Debug::BackdropFilter(v) => Real::BackdropFilter(v),
+
+ Debug::PopStackingContext => Real::PopStackingContext,
+ Debug::PopReferenceFrame => Real::PopReferenceFrame,
+ Debug::PopAllShadows => Real::PopAllShadows,
+ };
+ poke_into_vec(&item, &mut items_data);
+ // the aux data is serialized after the item, hence the temporary
+ items_data.extend(temp.drain(..));
+ }
+
+ // Add `DisplayItem::max_size` zone of zeroes to the end of display list
+ // so there is at least this amount available in the display list during
+ // serialization.
+ ensure_red_zone::<di::DisplayItem>(&mut items_data);
+
+ Ok(DisplayListWithCache {
+ display_list: BuiltDisplayList {
+ descriptor: capture.descriptor,
+ payload: DisplayListPayload {
+ cache_data: Vec::new(),
+ items_data,
+ spatial_tree,
+ },
+ },
+ cache: DisplayItemCache::new(),
+ })
+ }
+}
+
+pub struct BuiltDisplayListIter<'a> {
+ data: &'a [u8],
+ cache: Option<&'a DisplayItemCache>,
+ pending_items: std::slice::Iter<'a, CachedDisplayItem>,
+ cur_cached_item: Option<&'a CachedDisplayItem>,
+ cur_item: di::DisplayItem,
+ cur_stops: ItemRange<'a, di::GradientStop>,
+ cur_glyphs: ItemRange<'a, GlyphInstance>,
+ cur_filters: ItemRange<'a, di::FilterOp>,
+ cur_filter_data: Vec<TempFilterData<'a>>,
+ cur_filter_primitives: ItemRange<'a, di::FilterPrimitive>,
+ cur_clip_chain_items: ItemRange<'a, di::ClipId>,
+ cur_points: ItemRange<'a, LayoutPoint>,
+ peeking: Peek,
+ /// Should just be initialized but never populated in release builds
+ debug_stats: DebugStats,
+}
+
+/// Internal info used for more detailed analysis of serialized display lists
+#[allow(dead_code)]
+struct DebugStats {
+ /// Last address in the buffer we pointed to, for computing serialized sizes
+ last_addr: usize,
+ stats: HashMap<&'static str, ItemStats>,
+}
+
+impl DebugStats {
+ #[cfg(feature = "display_list_stats")]
+ fn _update_entry(&mut self, name: &'static str, item_count: usize, byte_count: usize) {
+ let entry = self.stats.entry(name).or_default();
+ entry.total_count += item_count;
+ entry.num_bytes += byte_count;
+ }
+
+ /// Computes the number of bytes we've processed since we last called
+ /// this method, so we can compute the serialized size of a display item.
+ #[cfg(feature = "display_list_stats")]
+ fn debug_num_bytes(&mut self, data: &[u8]) -> usize {
+ let old_addr = self.last_addr;
+ let new_addr = data.as_ptr() as usize;
+ let delta = new_addr - old_addr;
+ self.last_addr = new_addr;
+
+ delta
+ }
+
+ /// Logs stats for the last deserialized display item
+ #[cfg(feature = "display_list_stats")]
+ fn log_item(&mut self, data: &[u8], item: &di::DisplayItem) {
+ let num_bytes = self.debug_num_bytes(data);
+ self._update_entry(item.debug_name(), 1, num_bytes);
+ }
+
+ /// Logs the stats for the given serialized slice
+ #[cfg(feature = "display_list_stats")]
+ fn log_slice<T: Copy + Default + peek_poke::Peek>(
+ &mut self,
+ slice_name: &'static str,
+ range: &ItemRange<T>,
+ ) {
+ // Run this so log_item_stats is accurate, but ignore its result
+ // because log_slice_stats may be called after multiple slices have been
+ // processed, and the `range` has everything we need.
+ self.last_addr = range.bytes.as_ptr() as usize + range.bytes.len();
+
+ self._update_entry(slice_name, range.iter().len(), range.bytes.len());
+ }
+
+ #[cfg(not(feature = "display_list_stats"))]
+ fn log_slice<T>(&mut self, _slice_name: &str, _range: &ItemRange<T>) {
+ /* no-op */
+ }
+}
+
+/// Stats for an individual item
+#[derive(Copy, Clone, Debug, Default)]
+pub struct ItemStats {
+ /// How many instances of this kind of item we deserialized
+ pub total_count: usize,
+ /// How many bytes we processed for this kind of item
+ pub num_bytes: usize,
+}
+
+pub struct DisplayItemRef<'a: 'b, 'b> {
+ iter: &'b BuiltDisplayListIter<'a>,
+}
+
+// Some of these might just become ItemRanges
+impl<'a, 'b> DisplayItemRef<'a, 'b> {
+ // Creates a new iterator where this element's iterator is, to hack around borrowck.
+ pub fn sub_iter(&self) -> BuiltDisplayListIter<'a> {
+ self.iter.sub_iter()
+ }
+
+ pub fn item(&self) -> &di::DisplayItem {
+ self.iter.current_item()
+ }
+
+ pub fn clip_chain_items(&self) -> ItemRange<di::ClipId> {
+ self.iter.cur_clip_chain_items
+ }
+
+ pub fn points(&self) -> ItemRange<LayoutPoint> {
+ self.iter.cur_points
+ }
+
+ pub fn glyphs(&self) -> ItemRange<GlyphInstance> {
+ self.iter.glyphs()
+ }
+
+ pub fn gradient_stops(&self) -> ItemRange<di::GradientStop> {
+ self.iter.gradient_stops()
+ }
+
+ pub fn filters(&self) -> ItemRange<di::FilterOp> {
+ self.iter.cur_filters
+ }
+
+ pub fn filter_datas(&self) -> &Vec<TempFilterData> {
+ &self.iter.cur_filter_data
+ }
+
+ pub fn filter_primitives(&self) -> ItemRange<di::FilterPrimitive> {
+ self.iter.cur_filter_primitives
+ }
+}
+
+#[derive(PartialEq)]
+enum Peek {
+ StartPeeking,
+ IsPeeking,
+ NotPeeking,
+}
+
+#[derive(Clone)]
+pub struct AuxIter<'a, T> {
+ item: T,
+ data: &'a [u8],
+ size: usize,
+// _boo: PhantomData<T>,
+}
+
+impl BuiltDisplayList {
+ pub fn from_data(
+ payload: DisplayListPayload,
+ descriptor: BuiltDisplayListDescriptor,
+ ) -> Self {
+ BuiltDisplayList {
+ payload,
+ descriptor,
+ }
+ }
+
+ pub fn into_data(self) -> (DisplayListPayload, BuiltDisplayListDescriptor) {
+ (self.payload, self.descriptor)
+ }
+
+ pub fn items_data(&self) -> &[u8] {
+ &self.payload.items_data
+ }
+
+ pub fn cache_data(&self) -> &[u8] {
+ &self.payload.cache_data
+ }
+
+ pub fn descriptor(&self) -> &BuiltDisplayListDescriptor {
+ &self.descriptor
+ }
+
+ pub fn set_send_time_ns(&mut self, time: u64) {
+ self.descriptor.send_start_time = time;
+ }
+
+ pub fn times(&self) -> (u64, u64, u64) {
+ (
+ self.descriptor.builder_start_time,
+ self.descriptor.builder_finish_time,
+ self.descriptor.send_start_time,
+ )
+ }
+
+ pub fn gecko_display_list_stats(&self) -> (f64, bool) {
+ match self.descriptor.gecko_display_list_type {
+ GeckoDisplayListType::Full(duration) => (duration, true),
+ GeckoDisplayListType::Partial(duration) => (duration, false),
+ _ => (0.0, false)
+ }
+ }
+
+ pub fn total_clip_nodes(&self) -> usize {
+ self.descriptor.total_clip_nodes
+ }
+
+ pub fn total_spatial_nodes(&self) -> usize {
+ self.descriptor.total_spatial_nodes
+ }
+
+ pub fn iter(&self) -> BuiltDisplayListIter {
+ BuiltDisplayListIter::new(self.items_data(), None)
+ }
+
+ pub fn cache_data_iter(&self) -> BuiltDisplayListIter {
+ BuiltDisplayListIter::new(self.cache_data(), None)
+ }
+
+ pub fn iter_with_cache<'a>(
+ &'a self,
+ cache: &'a DisplayItemCache
+ ) -> BuiltDisplayListIter<'a> {
+ BuiltDisplayListIter::new(self.items_data(), Some(cache))
+ }
+
+ pub fn cache_size(&self) -> usize {
+ self.descriptor.cache_size
+ }
+
+ pub fn size_in_bytes(&self) -> usize {
+ self.payload.size_in_bytes()
+ }
+
+ pub fn iter_spatial_tree<F>(&self, f: F) where F: FnMut(&di::SpatialTreeItem) {
+ iter_spatial_tree(&self.payload.spatial_tree, f)
+ }
+
+ #[cfg(feature = "serialize")]
+ pub fn create_debug_display_items(
+ mut iterator: BuiltDisplayListIter,
+ ) -> Vec<di::DebugDisplayItem> {
+ use di::DisplayItem as Real;
+ use di::DebugDisplayItem as Debug;
+ let mut debug_items = Vec::new();
+
+ while let Some(item) = iterator.next_raw() {
+ let serial_di = match *item.item() {
+ Real::ClipChain(v) => Debug::ClipChain(
+ v,
+ item.iter.cur_clip_chain_items.iter().collect()
+ ),
+ Real::Text(v) => Debug::Text(
+ v,
+ item.iter.cur_glyphs.iter().collect()
+ ),
+ Real::SetFilterOps => Debug::SetFilterOps(
+ item.iter.cur_filters.iter().collect()
+ ),
+ Real::SetFilterData => {
+ debug_assert!(!item.iter.cur_filter_data.is_empty(),
+ "next_raw should have populated cur_filter_data");
+ let temp_filter_data = &item.iter.cur_filter_data[item.iter.cur_filter_data.len()-1];
+
+ let func_types: Vec<di::ComponentTransferFuncType> =
+ temp_filter_data.func_types.iter().collect();
+ debug_assert!(func_types.len() == 4,
+ "someone changed the number of filter funcs without updating this code");
+ Debug::SetFilterData(di::FilterData {
+ func_r_type: func_types[0],
+ r_values: temp_filter_data.r_values.iter().collect(),
+ func_g_type: func_types[1],
+ g_values: temp_filter_data.g_values.iter().collect(),
+ func_b_type: func_types[2],
+ b_values: temp_filter_data.b_values.iter().collect(),
+ func_a_type: func_types[3],
+ a_values: temp_filter_data.a_values.iter().collect(),
+ })
+ },
+ Real::SetFilterPrimitives => Debug::SetFilterPrimitives(
+ item.iter.cur_filter_primitives.iter().collect()
+ ),
+ Real::SetGradientStops => Debug::SetGradientStops(
+ item.iter.cur_stops.iter().collect()
+ ),
+ Real::SetPoints => Debug::SetPoints(
+ item.iter.cur_points.iter().collect()
+ ),
+ Real::RectClip(v) => Debug::RectClip(v),
+ Real::RoundedRectClip(v) => Debug::RoundedRectClip(v),
+ Real::ImageMaskClip(v) => Debug::ImageMaskClip(v),
+ Real::Rectangle(v) => Debug::Rectangle(v),
+ Real::ClearRectangle(v) => Debug::ClearRectangle(v),
+ Real::HitTest(v) => Debug::HitTest(v),
+ Real::Line(v) => Debug::Line(v),
+ Real::Image(v) => Debug::Image(v),
+ Real::RepeatingImage(v) => Debug::RepeatingImage(v),
+ Real::YuvImage(v) => Debug::YuvImage(v),
+ Real::Border(v) => Debug::Border(v),
+ Real::BoxShadow(v) => Debug::BoxShadow(v),
+ Real::Gradient(v) => Debug::Gradient(v),
+ Real::RadialGradient(v) => Debug::RadialGradient(v),
+ Real::ConicGradient(v) => Debug::ConicGradient(v),
+ Real::Iframe(v) => Debug::Iframe(v),
+ Real::PushReferenceFrame(v) => Debug::PushReferenceFrame(v),
+ Real::PushStackingContext(v) => Debug::PushStackingContext(v),
+ Real::PushShadow(v) => Debug::PushShadow(v),
+ Real::BackdropFilter(v) => Debug::BackdropFilter(v),
+
+ Real::PopReferenceFrame => Debug::PopReferenceFrame,
+ Real::PopStackingContext => Debug::PopStackingContext,
+ Real::PopAllShadows => Debug::PopAllShadows,
+ Real::ReuseItems(_) |
+ Real::RetainedItems(_) => unreachable!("Unexpected item"),
+ };
+ debug_items.push(serial_di);
+ }
+
+ debug_items
+ }
+}
+
+/// Returns the byte-range the slice occupied.
+fn skip_slice<'a, T: peek_poke::Peek>(data: &mut &'a [u8]) -> ItemRange<'a, T> {
+ let mut skip_offset = 0usize;
+ *data = peek_from_slice(data, &mut skip_offset);
+ let (skip, rest) = data.split_at(skip_offset);
+
+ // Adjust data pointer to skip read values
+ *data = rest;
+
+ ItemRange {
+ bytes: skip,
+ _boo: PhantomData,
+ }
+}
+
+impl<'a> BuiltDisplayListIter<'a> {
+ pub fn new(
+ data: &'a [u8],
+ cache: Option<&'a DisplayItemCache>,
+ ) -> Self {
+ Self {
+ data,
+ cache,
+ pending_items: [].iter(),
+ cur_cached_item: None,
+ cur_item: di::DisplayItem::PopStackingContext,
+ cur_stops: ItemRange::default(),
+ cur_glyphs: ItemRange::default(),
+ cur_filters: ItemRange::default(),
+ cur_filter_data: Vec::new(),
+ cur_filter_primitives: ItemRange::default(),
+ cur_clip_chain_items: ItemRange::default(),
+ cur_points: ItemRange::default(),
+ peeking: Peek::NotPeeking,
+ debug_stats: DebugStats {
+ last_addr: data.as_ptr() as usize,
+ stats: HashMap::default(),
+ },
+ }
+ }
+
+ pub fn sub_iter(&self) -> Self {
+ let mut iter = BuiltDisplayListIter::new(
+ self.data, self.cache
+ );
+ iter.pending_items = self.pending_items.clone();
+ iter
+ }
+
+ pub fn current_item(&self) -> &di::DisplayItem {
+ match self.cur_cached_item {
+ Some(cached_item) => cached_item.display_item(),
+ None => &self.cur_item
+ }
+ }
+
+ fn cached_item_range_or<T>(
+ &self,
+ data: ItemRange<'a, T>
+ ) -> ItemRange<'a, T> {
+ match self.cur_cached_item {
+ Some(cached_item) => cached_item.data_as_item_range(),
+ None => data,
+ }
+ }
+
+ pub fn glyphs(&self) -> ItemRange<GlyphInstance> {
+ self.cached_item_range_or(self.cur_glyphs)
+ }
+
+ pub fn gradient_stops(&self) -> ItemRange<di::GradientStop> {
+ self.cached_item_range_or(self.cur_stops)
+ }
+
+ fn advance_pending_items(&mut self) -> bool {
+ self.cur_cached_item = self.pending_items.next();
+ self.cur_cached_item.is_some()
+ }
+
+ pub fn next<'b>(&'b mut self) -> Option<DisplayItemRef<'a, 'b>> {
+ use crate::DisplayItem::*;
+
+ match self.peeking {
+ Peek::IsPeeking => {
+ self.peeking = Peek::NotPeeking;
+ return Some(self.as_ref());
+ }
+ Peek::StartPeeking => {
+ self.peeking = Peek::IsPeeking;
+ }
+ Peek::NotPeeking => { /* do nothing */ }
+ }
+
+ // Don't let these bleed into another item
+ self.cur_stops = ItemRange::default();
+ self.cur_clip_chain_items = ItemRange::default();
+ self.cur_points = ItemRange::default();
+ self.cur_filters = ItemRange::default();
+ self.cur_filter_primitives = ItemRange::default();
+ self.cur_filter_data.clear();
+
+ loop {
+ self.next_raw()?;
+ match self.cur_item {
+ SetGradientStops |
+ SetFilterOps |
+ SetFilterData |
+ SetFilterPrimitives |
+ SetPoints => {
+ // These are marker items for populating other display items, don't yield them.
+ continue;
+ }
+ _ => {
+ break;
+ }
+ }
+ }
+
+ Some(self.as_ref())
+ }
+
+ /// Gets the next display item, even if it's a dummy. Also doesn't handle peeking
+ /// and may leave irrelevant ranges live (so a Clip may have GradientStops if
+ /// for some reason you ask).
+ pub fn next_raw<'b>(&'b mut self) -> Option<DisplayItemRef<'a, 'b>> {
+ use crate::DisplayItem::*;
+
+ if self.advance_pending_items() {
+ return Some(self.as_ref());
+ }
+
+ // A "red zone" of DisplayItem::max_size() bytes has been added to the
+ // end of the serialized display list. If this amount, or less, is
+ // remaining then we've reached the end of the display list.
+ if self.data.len() <= di::DisplayItem::max_size() {
+ return None;
+ }
+
+ self.data = peek_from_slice(self.data, &mut self.cur_item);
+ self.log_item_stats();
+
+ match self.cur_item {
+ SetGradientStops => {
+ self.cur_stops = skip_slice::<di::GradientStop>(&mut self.data);
+ self.debug_stats.log_slice("set_gradient_stops.stops", &self.cur_stops);
+ }
+ SetFilterOps => {
+ self.cur_filters = skip_slice::<di::FilterOp>(&mut self.data);
+ self.debug_stats.log_slice("set_filter_ops.ops", &self.cur_filters);
+ }
+ SetFilterData => {
+ self.cur_filter_data.push(TempFilterData {
+ func_types: skip_slice::<di::ComponentTransferFuncType>(&mut self.data),
+ r_values: skip_slice::<f32>(&mut self.data),
+ g_values: skip_slice::<f32>(&mut self.data),
+ b_values: skip_slice::<f32>(&mut self.data),
+ a_values: skip_slice::<f32>(&mut self.data),
+ });
+
+ let data = *self.cur_filter_data.last().unwrap();
+ self.debug_stats.log_slice("set_filter_data.func_types", &data.func_types);
+ self.debug_stats.log_slice("set_filter_data.r_values", &data.r_values);
+ self.debug_stats.log_slice("set_filter_data.g_values", &data.g_values);
+ self.debug_stats.log_slice("set_filter_data.b_values", &data.b_values);
+ self.debug_stats.log_slice("set_filter_data.a_values", &data.a_values);
+ }
+ SetFilterPrimitives => {
+ self.cur_filter_primitives = skip_slice::<di::FilterPrimitive>(&mut self.data);
+ self.debug_stats.log_slice("set_filter_primitives.primitives", &self.cur_filter_primitives);
+ }
+ SetPoints => {
+ self.cur_points = skip_slice::<LayoutPoint>(&mut self.data);
+ self.debug_stats.log_slice("set_points.points", &self.cur_points);
+ }
+ ClipChain(_) => {
+ self.cur_clip_chain_items = skip_slice::<di::ClipId>(&mut self.data);
+ self.debug_stats.log_slice("clip_chain.clip_ids", &self.cur_clip_chain_items);
+ }
+ Text(_) => {
+ self.cur_glyphs = skip_slice::<GlyphInstance>(&mut self.data);
+ self.debug_stats.log_slice("text.glyphs", &self.cur_glyphs);
+ }
+ ReuseItems(key) => {
+ match self.cache {
+ Some(cache) => {
+ self.pending_items = cache.get_items(key).iter();
+ self.advance_pending_items();
+ }
+ None => {
+ unreachable!("Cache marker without cache!");
+ }
+ }
+ }
+ _ => { /* do nothing */ }
+ }
+
+ Some(self.as_ref())
+ }
+
+ pub fn as_ref<'b>(&'b self) -> DisplayItemRef<'a, 'b> {
+ DisplayItemRef {
+ iter: self,
+ }
+ }
+
+ pub fn skip_current_stacking_context(&mut self) {
+ let mut depth = 0;
+ while let Some(item) = self.next() {
+ match *item.item() {
+ di::DisplayItem::PushStackingContext(..) => depth += 1,
+ di::DisplayItem::PopStackingContext if depth == 0 => return,
+ di::DisplayItem::PopStackingContext => depth -= 1,
+ _ => {}
+ }
+ }
+ }
+
+ pub fn current_stacking_context_empty(&mut self) -> bool {
+ match self.peek() {
+ Some(item) => *item.item() == di::DisplayItem::PopStackingContext,
+ None => true,
+ }
+ }
+
+ pub fn peek<'b>(&'b mut self) -> Option<DisplayItemRef<'a, 'b>> {
+ if self.peeking == Peek::NotPeeking {
+ self.peeking = Peek::StartPeeking;
+ self.next()
+ } else {
+ Some(self.as_ref())
+ }
+ }
+
+ /// Get the debug stats for what this iterator has deserialized.
+ /// Should always be empty in release builds.
+ pub fn debug_stats(&mut self) -> Vec<(&'static str, ItemStats)> {
+ let mut result = self.debug_stats.stats.drain().collect::<Vec<_>>();
+ result.sort_by_key(|stats| stats.0);
+ result
+ }
+
+ /// Adds the debug stats from another to our own, assuming we are a sub-iter of the other
+ /// (so we can ignore where they were in the traversal).
+ pub fn merge_debug_stats_from(&mut self, other: &mut Self) {
+ for (key, other_entry) in other.debug_stats.stats.iter() {
+ let entry = self.debug_stats.stats.entry(key).or_default();
+
+ entry.total_count += other_entry.total_count;
+ entry.num_bytes += other_entry.num_bytes;
+ }
+ }
+
+ /// Logs stats for the last deserialized display item
+ #[cfg(feature = "display_list_stats")]
+ fn log_item_stats(&mut self) {
+ self.debug_stats.log_item(self.data, &self.cur_item);
+ }
+
+ #[cfg(not(feature = "display_list_stats"))]
+ fn log_item_stats(&mut self) { /* no-op */ }
+}
+
+impl<'a, T> AuxIter<'a, T> {
+ pub fn new(item: T, mut data: &'a [u8]) -> Self {
+ let mut size = 0usize;
+ if !data.is_empty() {
+ data = peek_from_slice(data, &mut size);
+ };
+
+ AuxIter {
+ item,
+ data,
+ size,
+// _boo: PhantomData,
+ }
+ }
+}
+
+impl<'a, T: Copy + peek_poke::Peek> Iterator for AuxIter<'a, T> {
+ type Item = T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.size == 0 {
+ None
+ } else {
+ self.size -= 1;
+ self.data = peek_from_slice(self.data, &mut self.item);
+ Some(self.item)
+ }
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.size, Some(self.size))
+ }
+}
+
+impl<'a, T: Copy + peek_poke::Peek> ::std::iter::ExactSizeIterator for AuxIter<'a, T> {}
+
+#[derive(Clone, Debug)]
+pub struct SaveState {
+ dl_items_len: usize,
+ dl_cache_len: usize,
+ next_clip_index: usize,
+ next_spatial_index: usize,
+ next_clip_chain_id: u64,
+}
+
+/// DisplayListSection determines the target buffer for the display items.
+pub enum DisplayListSection {
+ /// The main/default buffer: contains item data and item group markers.
+ Data,
+ /// Auxiliary buffer: contains the item data for item groups.
+ CacheData,
+ /// Temporary buffer: contains the data for pending item group. Flushed to
+ /// one of the buffers above, after item grouping finishes.
+ Chunk,
+}
+
+/// A small portion of a normal spatial node that we store during DL construction to
+/// enable snapping and reference frame <-> stacking context coord mapping. In future
+/// we'll aim to remove this and have the full spatial tree available during DL build.
+#[derive(Clone)]
+pub struct SpatialNodeInfo {
+ /// The total external scroll offset applicable at this node
+ accumulated_external_scroll_offset: LayoutVector2D,
+}
+
+impl SpatialNodeInfo {
+ fn identity() -> Self {
+ SpatialNodeInfo {
+ accumulated_external_scroll_offset: LayoutVector2D::zero(),
+ }
+ }
+}
+
+pub struct DisplayListBuilder {
+ payload: DisplayListPayload,
+ pub pipeline_id: PipelineId,
+
+ pending_chunk: Vec<u8>,
+ writing_to_chunk: bool,
+
+ next_clip_index: usize,
+ next_spatial_index: usize,
+ next_clip_chain_id: u64,
+ builder_start_time: u64,
+
+ save_state: Option<SaveState>,
+
+ cache_size: usize,
+ serialized_content_buffer: Option<String>,
+ state: BuildState,
+
+ /// Helper struct to map stacking context coords <-> reference frame coords.
+ rf_mapper: ReferenceFrameMapper,
+
+ /// Minimal info about encountered spatial nodes to allow snapping during DL building
+ spatial_nodes: Vec<SpatialNodeInfo>,
+}
+
+#[repr(C)]
+struct DisplayListCapacity {
+ items_size: usize,
+ cache_size: usize,
+ spatial_tree_size: usize,
+}
+
+impl DisplayListCapacity {
+ fn empty() -> Self {
+ DisplayListCapacity {
+ items_size: 0,
+ cache_size: 0,
+ spatial_tree_size: 0,
+ }
+ }
+}
+
+impl DisplayListBuilder {
+ pub fn new(pipeline_id: PipelineId) -> Self {
+ DisplayListBuilder {
+ payload: DisplayListPayload::new(DisplayListCapacity::empty()),
+ pipeline_id,
+
+ pending_chunk: Vec::new(),
+ writing_to_chunk: false,
+
+ next_clip_index: FIRST_CLIP_NODE_INDEX,
+ next_spatial_index: FIRST_SPATIAL_NODE_INDEX,
+ next_clip_chain_id: 0,
+ builder_start_time: 0,
+ save_state: None,
+ cache_size: 0,
+ serialized_content_buffer: None,
+ state: BuildState::Idle,
+
+ rf_mapper: ReferenceFrameMapper::new(),
+ spatial_nodes: vec![SpatialNodeInfo::identity(); FIRST_SPATIAL_NODE_INDEX + 1],
+ }
+ }
+
+ fn reset(&mut self) {
+ self.payload.clear();
+ self.pending_chunk.clear();
+ self.writing_to_chunk = false;
+
+ self.next_clip_index = FIRST_CLIP_NODE_INDEX;
+ self.next_spatial_index = FIRST_SPATIAL_NODE_INDEX;
+ self.next_clip_chain_id = 0;
+
+ self.save_state = None;
+ self.cache_size = 0;
+ self.serialized_content_buffer = None;
+
+ self.rf_mapper = ReferenceFrameMapper::new();
+ self.spatial_nodes = vec![SpatialNodeInfo::identity(); FIRST_SPATIAL_NODE_INDEX + 1];
+ }
+
+ /// Saves the current display list state, so it may be `restore()`'d.
+ ///
+ /// # Conditions:
+ ///
+ /// * Doesn't support popping clips that were pushed before the save.
+ /// * Doesn't support nested saves.
+ /// * Must call `clear_save()` if the restore becomes unnecessary.
+ pub fn save(&mut self) {
+ assert!(self.save_state.is_none(), "DisplayListBuilder doesn't support nested saves");
+
+ self.save_state = Some(SaveState {
+ dl_items_len: self.payload.items_data.len(),
+ dl_cache_len: self.payload.cache_data.len(),
+ next_clip_index: self.next_clip_index,
+ next_spatial_index: self.next_spatial_index,
+ next_clip_chain_id: self.next_clip_chain_id,
+ });
+ }
+
+ /// Restores the state of the builder to when `save()` was last called.
+ pub fn restore(&mut self) {
+ let state = self.save_state.take().expect("No save to restore DisplayListBuilder from");
+
+ self.payload.items_data.truncate(state.dl_items_len);
+ self.payload.cache_data.truncate(state.dl_cache_len);
+ self.next_clip_index = state.next_clip_index;
+ self.next_spatial_index = state.next_spatial_index;
+ self.next_clip_chain_id = state.next_clip_chain_id;
+ }
+
+ /// Discards the builder's save (indicating the attempted operation was successful).
+ pub fn clear_save(&mut self) {
+ self.save_state.take().expect("No save to clear in DisplayListBuilder");
+ }
+
+ /// Emits a debug representation of display items in the list, for debugging
+ /// purposes. If the range's start parameter is specified, only display
+ /// items starting at that index (inclusive) will be printed. If the range's
+ /// end parameter is specified, only display items before that index
+ /// (exclusive) will be printed. Calling this function with end <= start is
+ /// allowed but is just a waste of CPU cycles. The function emits the
+ /// debug representation of the selected display items, one per line, with
+ /// the given indent, to the provided sink object. The return value is
+ /// the total number of items in the display list, which allows the
+ /// caller to subsequently invoke this function to only dump the newly-added
+ /// items.
+ pub fn emit_display_list<W>(
+ &mut self,
+ indent: usize,
+ range: Range<Option<usize>>,
+ mut sink: W,
+ ) -> usize
+ where
+ W: Write
+ {
+ let mut temp = BuiltDisplayList::default();
+ ensure_red_zone::<di::DisplayItem>(&mut self.payload.items_data);
+ ensure_red_zone::<di::DisplayItem>(&mut self.payload.cache_data);
+ mem::swap(&mut temp.payload, &mut self.payload);
+
+ let mut index: usize = 0;
+ {
+ let mut cache = DisplayItemCache::new();
+ cache.update(&temp);
+ let mut iter = temp.iter_with_cache(&cache);
+ while let Some(item) = iter.next_raw() {
+ if index >= range.start.unwrap_or(0) && range.end.map_or(true, |e| index < e) {
+ writeln!(sink, "{}{:?}", " ".repeat(indent), item.item()).unwrap();
+ }
+ index += 1;
+ }
+ }
+
+ self.payload = temp.payload;
+ strip_red_zone::<di::DisplayItem>(&mut self.payload.items_data);
+ strip_red_zone::<di::DisplayItem>(&mut self.payload.cache_data);
+ index
+ }
+
+ /// Print the display items in the list to stdout.
+ pub fn dump_serialized_display_list(&mut self) {
+ self.serialized_content_buffer = Some(String::new());
+ }
+
+ fn add_to_display_list_dump<T: std::fmt::Debug>(&mut self, item: T) {
+ if let Some(ref mut content) = self.serialized_content_buffer {
+ use std::fmt::Write;
+ write!(content, "{:?}\n", item).expect("DL dump write failed.");
+ }
+ }
+
+ /// Returns the default section that DisplayListBuilder will write to,
+ /// if no section is specified explicitly.
+ fn default_section(&self) -> DisplayListSection {
+ if self.writing_to_chunk {
+ DisplayListSection::Chunk
+ } else {
+ DisplayListSection::Data
+ }
+ }
+
+ fn buffer_from_section(
+ &mut self,
+ section: DisplayListSection
+ ) -> &mut Vec<u8> {
+ match section {
+ DisplayListSection::Data => &mut self.payload.items_data,
+ DisplayListSection::CacheData => &mut self.payload.cache_data,
+ DisplayListSection::Chunk => &mut self.pending_chunk,
+ }
+ }
+
+ #[inline]
+ pub fn push_item_to_section(
+ &mut self,
+ item: &di::DisplayItem,
+ section: DisplayListSection,
+ ) {
+ debug_assert_eq!(self.state, BuildState::Build);
+ poke_into_vec(item, self.buffer_from_section(section));
+ self.add_to_display_list_dump(item);
+ }
+
+ /// Add an item to the display list.
+ ///
+ /// NOTE: It is usually preferable to use the specialized methods to push
+ /// display items. Pushing unexpected or invalid items here may
+ /// result in WebRender panicking or behaving in unexpected ways.
+ #[inline]
+ pub fn push_item(&mut self, item: &di::DisplayItem) {
+ self.push_item_to_section(item, self.default_section());
+ }
+
+ #[inline]
+ pub fn push_spatial_tree_item(&mut self, item: &di::SpatialTreeItem) {
+ debug_assert_eq!(self.state, BuildState::Build);
+ poke_into_vec(item, &mut self.payload.spatial_tree);
+ }
+
+ fn push_iter_impl<I>(data: &mut Vec<u8>, iter_source: I)
+ where
+ I: IntoIterator,
+ I::IntoIter: ExactSizeIterator,
+ I::Item: Poke,
+ {
+ let iter = iter_source.into_iter();
+ let len = iter.len();
+ // Format:
+ // payload_byte_size: usize, item_count: usize, [I; item_count]
+
+ // Track the the location of where to write byte size with offsets
+ // instead of pointers because data may be moved in memory during
+ // `serialize_iter_fast`.
+ let byte_size_offset = data.len();
+
+ // We write a dummy value so there's room for later
+ poke_into_vec(&0usize, data);
+ poke_into_vec(&len, data);
+ let count = poke_extend_vec(iter, data);
+ debug_assert_eq!(len, count, "iterator.len() returned two different values");
+
+ // Add red zone
+ ensure_red_zone::<I::Item>(data);
+
+ // Now write the actual byte_size
+ let final_offset = data.len();
+ debug_assert!(final_offset >= (byte_size_offset + mem::size_of::<usize>()),
+ "space was never allocated for this array's byte_size");
+ let byte_size = final_offset - byte_size_offset - mem::size_of::<usize>();
+ poke_inplace_slice(&byte_size, &mut data[byte_size_offset..]);
+ }
+
+ /// Push items from an iterator to the display list.
+ ///
+ /// NOTE: Pushing unexpected or invalid items to the display list
+ /// may result in panic and confusion.
+ pub fn push_iter<I>(&mut self, iter: I)
+ where
+ I: IntoIterator,
+ I::IntoIter: ExactSizeIterator,
+ I::Item: Poke,
+ {
+ assert_eq!(self.state, BuildState::Build);
+
+ let mut buffer = self.buffer_from_section(self.default_section());
+ Self::push_iter_impl(&mut buffer, iter);
+ }
+
+ pub fn push_rect(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ color: ColorF,
+ ) {
+ let item = di::DisplayItem::Rectangle(di::RectangleDisplayItem {
+ common: *common,
+ color: PropertyBinding::Value(color),
+ bounds,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_rect_with_animation(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ color: PropertyBinding<ColorF>,
+ ) {
+ let item = di::DisplayItem::Rectangle(di::RectangleDisplayItem {
+ common: *common,
+ color,
+ bounds,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_clear_rect(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ ) {
+ let item = di::DisplayItem::ClearRectangle(di::ClearRectangleDisplayItem {
+ common: *common,
+ bounds,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_hit_test(
+ &mut self,
+ rect: LayoutRect,
+ clip_chain_id: di::ClipChainId,
+ spatial_id: di::SpatialId,
+ flags: di::PrimitiveFlags,
+ tag: di::ItemTag,
+ ) {
+ let item = di::DisplayItem::HitTest(di::HitTestDisplayItem {
+ rect,
+ clip_chain_id,
+ spatial_id,
+ flags,
+ tag,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_line(
+ &mut self,
+ common: &di::CommonItemProperties,
+ area: &LayoutRect,
+ wavy_line_thickness: f32,
+ orientation: di::LineOrientation,
+ color: &ColorF,
+ style: di::LineStyle,
+ ) {
+ let item = di::DisplayItem::Line(di::LineDisplayItem {
+ common: *common,
+ area: *area,
+ wavy_line_thickness,
+ orientation,
+ color: *color,
+ style,
+ });
+
+ self.push_item(&item);
+ }
+
+ pub fn push_image(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ image_rendering: di::ImageRendering,
+ alpha_type: di::AlphaType,
+ key: ImageKey,
+ color: ColorF,
+ ) {
+ let item = di::DisplayItem::Image(di::ImageDisplayItem {
+ common: *common,
+ bounds,
+ image_key: key,
+ image_rendering,
+ alpha_type,
+ color,
+ });
+
+ self.push_item(&item);
+ }
+
+ pub fn push_repeating_image(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ stretch_size: LayoutSize,
+ tile_spacing: LayoutSize,
+ image_rendering: di::ImageRendering,
+ alpha_type: di::AlphaType,
+ key: ImageKey,
+ color: ColorF,
+ ) {
+ let item = di::DisplayItem::RepeatingImage(di::RepeatingImageDisplayItem {
+ common: *common,
+ bounds,
+ image_key: key,
+ stretch_size,
+ tile_spacing,
+ image_rendering,
+ alpha_type,
+ color,
+ });
+
+ self.push_item(&item);
+ }
+
+ /// Push a yuv image. All planar data in yuv image should use the same buffer type.
+ pub fn push_yuv_image(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ yuv_data: di::YuvData,
+ color_depth: ColorDepth,
+ color_space: di::YuvColorSpace,
+ color_range: di::ColorRange,
+ image_rendering: di::ImageRendering,
+ ) {
+ let item = di::DisplayItem::YuvImage(di::YuvImageDisplayItem {
+ common: *common,
+ bounds,
+ yuv_data,
+ color_depth,
+ color_space,
+ color_range,
+ image_rendering,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_text(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ glyphs: &[GlyphInstance],
+ font_key: FontInstanceKey,
+ color: ColorF,
+ glyph_options: Option<GlyphOptions>,
+ ) {
+ let item = di::DisplayItem::Text(di::TextDisplayItem {
+ common: *common,
+ bounds,
+ color,
+ font_key,
+ glyph_options,
+ });
+
+ for split_glyphs in glyphs.chunks(MAX_TEXT_RUN_LENGTH) {
+ self.push_item(&item);
+ self.push_iter(split_glyphs);
+ }
+ }
+
+ /// NOTE: gradients must be pushed in the order they're created
+ /// because create_gradient stores the stops in anticipation.
+ pub fn create_gradient(
+ &mut self,
+ start_point: LayoutPoint,
+ end_point: LayoutPoint,
+ stops: Vec<di::GradientStop>,
+ extend_mode: di::ExtendMode,
+ ) -> di::Gradient {
+ let mut builder = GradientBuilder::with_stops(stops);
+ let gradient = builder.gradient(start_point, end_point, extend_mode);
+ self.push_stops(builder.stops());
+ gradient
+ }
+
+ /// NOTE: gradients must be pushed in the order they're created
+ /// because create_gradient stores the stops in anticipation.
+ pub fn create_radial_gradient(
+ &mut self,
+ center: LayoutPoint,
+ radius: LayoutSize,
+ stops: Vec<di::GradientStop>,
+ extend_mode: di::ExtendMode,
+ ) -> di::RadialGradient {
+ let mut builder = GradientBuilder::with_stops(stops);
+ let gradient = builder.radial_gradient(center, radius, extend_mode);
+ self.push_stops(builder.stops());
+ gradient
+ }
+
+ /// NOTE: gradients must be pushed in the order they're created
+ /// because create_gradient stores the stops in anticipation.
+ pub fn create_conic_gradient(
+ &mut self,
+ center: LayoutPoint,
+ angle: f32,
+ stops: Vec<di::GradientStop>,
+ extend_mode: di::ExtendMode,
+ ) -> di::ConicGradient {
+ let mut builder = GradientBuilder::with_stops(stops);
+ let gradient = builder.conic_gradient(center, angle, extend_mode);
+ self.push_stops(builder.stops());
+ gradient
+ }
+
+ pub fn push_border(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ widths: LayoutSideOffsets,
+ details: di::BorderDetails,
+ ) {
+ let item = di::DisplayItem::Border(di::BorderDisplayItem {
+ common: *common,
+ bounds,
+ details,
+ widths,
+ });
+
+ self.push_item(&item);
+ }
+
+ pub fn push_box_shadow(
+ &mut self,
+ common: &di::CommonItemProperties,
+ box_bounds: LayoutRect,
+ offset: LayoutVector2D,
+ color: ColorF,
+ blur_radius: f32,
+ spread_radius: f32,
+ border_radius: di::BorderRadius,
+ clip_mode: di::BoxShadowClipMode,
+ ) {
+ let item = di::DisplayItem::BoxShadow(di::BoxShadowDisplayItem {
+ common: *common,
+ box_bounds,
+ offset,
+ color,
+ blur_radius,
+ spread_radius,
+ border_radius,
+ clip_mode,
+ });
+
+ self.push_item(&item);
+ }
+
+ /// Pushes a linear gradient to be displayed.
+ ///
+ /// The gradient itself is described in the
+ /// `gradient` parameter. It is drawn on
+ /// a "tile" with the dimensions from `tile_size`.
+ /// These tiles are now repeated to the right and
+ /// to the bottom infinitely. If `tile_spacing`
+ /// is not zero spacers with the given dimensions
+ /// are inserted between the tiles as seams.
+ ///
+ /// The origin of the tiles is given in `layout.rect.origin`.
+ /// If the gradient should only be displayed once limit
+ /// the `layout.rect.size` to a single tile.
+ /// The gradient is only visible within the local clip.
+ pub fn push_gradient(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ gradient: di::Gradient,
+ tile_size: LayoutSize,
+ tile_spacing: LayoutSize,
+ ) {
+ let item = di::DisplayItem::Gradient(di::GradientDisplayItem {
+ common: *common,
+ bounds,
+ gradient,
+ tile_size,
+ tile_spacing,
+ });
+
+ self.push_item(&item);
+ }
+
+ /// Pushes a radial gradient to be displayed.
+ ///
+ /// See [`push_gradient`](#method.push_gradient) for explanation.
+ pub fn push_radial_gradient(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ gradient: di::RadialGradient,
+ tile_size: LayoutSize,
+ tile_spacing: LayoutSize,
+ ) {
+ let item = di::DisplayItem::RadialGradient(di::RadialGradientDisplayItem {
+ common: *common,
+ bounds,
+ gradient,
+ tile_size,
+ tile_spacing,
+ });
+
+ self.push_item(&item);
+ }
+
+ /// Pushes a conic gradient to be displayed.
+ ///
+ /// See [`push_gradient`](#method.push_gradient) for explanation.
+ pub fn push_conic_gradient(
+ &mut self,
+ common: &di::CommonItemProperties,
+ bounds: LayoutRect,
+ gradient: di::ConicGradient,
+ tile_size: LayoutSize,
+ tile_spacing: LayoutSize,
+ ) {
+ let item = di::DisplayItem::ConicGradient(di::ConicGradientDisplayItem {
+ common: *common,
+ bounds,
+ gradient,
+ tile_size,
+ tile_spacing,
+ });
+
+ self.push_item(&item);
+ }
+
+ pub fn push_reference_frame(
+ &mut self,
+ origin: LayoutPoint,
+ parent_spatial_id: di::SpatialId,
+ transform_style: di::TransformStyle,
+ transform: PropertyBinding<LayoutTransform>,
+ kind: di::ReferenceFrameKind,
+ key: di::SpatialTreeItemKey,
+ ) -> di::SpatialId {
+ let id = self.generate_spatial_index();
+
+ let current_offset = self.current_offset(parent_spatial_id);
+ let origin = origin + current_offset;
+
+ self.add_spatial_node_info(
+ id,
+ LayoutVector2D::zero(),
+ );
+
+ let descriptor = di::SpatialTreeItem::ReferenceFrame(di::ReferenceFrameDescriptor {
+ parent_spatial_id,
+ origin,
+ reference_frame: di::ReferenceFrame {
+ transform_style,
+ transform: di::ReferenceTransformBinding::Static {
+ binding: transform,
+ },
+ kind,
+ id,
+ key,
+ },
+ });
+ self.push_spatial_tree_item(&descriptor);
+
+ self.rf_mapper.push_scope();
+
+ let item = di::DisplayItem::PushReferenceFrame(di::ReferenceFrameDisplayListItem {
+ });
+ self.push_item(&item);
+
+ id
+ }
+
+ pub fn push_computed_frame(
+ &mut self,
+ origin: LayoutPoint,
+ parent_spatial_id: di::SpatialId,
+ scale_from: Option<LayoutSize>,
+ vertical_flip: bool,
+ rotation: di::Rotation,
+ key: di::SpatialTreeItemKey,
+ ) -> di::SpatialId {
+ let id = self.generate_spatial_index();
+
+ let current_offset = self.current_offset(parent_spatial_id);
+ let origin = origin + current_offset;
+
+ let descriptor = di::SpatialTreeItem::ReferenceFrame(di::ReferenceFrameDescriptor {
+ parent_spatial_id,
+ origin,
+ reference_frame: di::ReferenceFrame {
+ transform_style: di::TransformStyle::Flat,
+ transform: di::ReferenceTransformBinding::Computed {
+ scale_from,
+ vertical_flip,
+ rotation,
+ },
+ kind: di::ReferenceFrameKind::Transform {
+ is_2d_scale_translation: false,
+ should_snap: false,
+ paired_with_perspective: false,
+ },
+ id,
+ key,
+ },
+ });
+ self.push_spatial_tree_item(&descriptor);
+
+ self.rf_mapper.push_scope();
+
+ let item = di::DisplayItem::PushReferenceFrame(di::ReferenceFrameDisplayListItem {
+ });
+ self.push_item(&item);
+
+ id
+ }
+
+ pub fn pop_reference_frame(&mut self) {
+ self.rf_mapper.pop_scope();
+ self.push_item(&di::DisplayItem::PopReferenceFrame);
+ }
+
+ pub fn push_stacking_context(
+ &mut self,
+ origin: LayoutPoint,
+ spatial_id: di::SpatialId,
+ prim_flags: di::PrimitiveFlags,
+ clip_chain_id: Option<di::ClipChainId>,
+ transform_style: di::TransformStyle,
+ mix_blend_mode: di::MixBlendMode,
+ filters: &[di::FilterOp],
+ filter_datas: &[di::FilterData],
+ filter_primitives: &[di::FilterPrimitive],
+ raster_space: di::RasterSpace,
+ flags: di::StackingContextFlags,
+ ) {
+ self.push_filters(filters, filter_datas, filter_primitives);
+
+ let item = di::DisplayItem::PushStackingContext(di::PushStackingContextDisplayItem {
+ origin,
+ spatial_id,
+ prim_flags,
+ stacking_context: di::StackingContext {
+ transform_style,
+ mix_blend_mode,
+ clip_chain_id,
+ raster_space,
+ flags,
+ },
+ });
+
+ self.rf_mapper.push_offset(origin.to_vector());
+ self.push_item(&item);
+ }
+
+ /// Helper for examples/ code.
+ pub fn push_simple_stacking_context(
+ &mut self,
+ origin: LayoutPoint,
+ spatial_id: di::SpatialId,
+ prim_flags: di::PrimitiveFlags,
+ ) {
+ self.push_simple_stacking_context_with_filters(
+ origin,
+ spatial_id,
+ prim_flags,
+ &[],
+ &[],
+ &[],
+ );
+ }
+
+ /// Helper for examples/ code.
+ pub fn push_simple_stacking_context_with_filters(
+ &mut self,
+ origin: LayoutPoint,
+ spatial_id: di::SpatialId,
+ prim_flags: di::PrimitiveFlags,
+ filters: &[di::FilterOp],
+ filter_datas: &[di::FilterData],
+ filter_primitives: &[di::FilterPrimitive],
+ ) {
+ self.push_stacking_context(
+ origin,
+ spatial_id,
+ prim_flags,
+ None,
+ di::TransformStyle::Flat,
+ di::MixBlendMode::Normal,
+ filters,
+ filter_datas,
+ filter_primitives,
+ di::RasterSpace::Screen,
+ di::StackingContextFlags::empty(),
+ );
+ }
+
+ pub fn pop_stacking_context(&mut self) {
+ self.rf_mapper.pop_offset();
+ self.push_item(&di::DisplayItem::PopStackingContext);
+ }
+
+ pub fn push_stops(&mut self, stops: &[di::GradientStop]) {
+ if stops.is_empty() {
+ return;
+ }
+ self.push_item(&di::DisplayItem::SetGradientStops);
+ self.push_iter(stops);
+ }
+
+ pub fn push_backdrop_filter(
+ &mut self,
+ common: &di::CommonItemProperties,
+ filters: &[di::FilterOp],
+ filter_datas: &[di::FilterData],
+ filter_primitives: &[di::FilterPrimitive],
+ ) {
+ self.push_filters(filters, filter_datas, filter_primitives);
+
+ let item = di::DisplayItem::BackdropFilter(di::BackdropFilterDisplayItem {
+ common: *common,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_filters(
+ &mut self,
+ filters: &[di::FilterOp],
+ filter_datas: &[di::FilterData],
+ filter_primitives: &[di::FilterPrimitive],
+ ) {
+ if !filters.is_empty() {
+ self.push_item(&di::DisplayItem::SetFilterOps);
+ self.push_iter(filters);
+ }
+
+ for filter_data in filter_datas {
+ let func_types = [
+ filter_data.func_r_type, filter_data.func_g_type,
+ filter_data.func_b_type, filter_data.func_a_type];
+ self.push_item(&di::DisplayItem::SetFilterData);
+ self.push_iter(&func_types);
+ self.push_iter(&filter_data.r_values);
+ self.push_iter(&filter_data.g_values);
+ self.push_iter(&filter_data.b_values);
+ self.push_iter(&filter_data.a_values);
+ }
+
+ if !filter_primitives.is_empty() {
+ self.push_item(&di::DisplayItem::SetFilterPrimitives);
+ self.push_iter(filter_primitives);
+ }
+ }
+
+ fn generate_clip_index(&mut self) -> di::ClipId {
+ self.next_clip_index += 1;
+ di::ClipId(self.next_clip_index - 1, self.pipeline_id)
+ }
+
+ fn generate_spatial_index(&mut self) -> di::SpatialId {
+ self.next_spatial_index += 1;
+ di::SpatialId::new(self.next_spatial_index - 1, self.pipeline_id)
+ }
+
+ fn generate_clip_chain_id(&mut self) -> di::ClipChainId {
+ self.next_clip_chain_id += 1;
+ di::ClipChainId(self.next_clip_chain_id - 1, self.pipeline_id)
+ }
+
+ pub fn define_scroll_frame(
+ &mut self,
+ parent_space: di::SpatialId,
+ external_id: di::ExternalScrollId,
+ content_rect: LayoutRect,
+ frame_rect: LayoutRect,
+ external_scroll_offset: LayoutVector2D,
+ scroll_offset_generation: APZScrollGeneration,
+ has_scroll_linked_effect: HasScrollLinkedEffect,
+ key: di::SpatialTreeItemKey,
+ ) -> di::SpatialId {
+ let scroll_frame_id = self.generate_spatial_index();
+ let current_offset = self.current_offset(parent_space);
+
+ let parent = self.spatial_nodes[parent_space.0].clone();
+
+ self.add_spatial_node_info(
+ scroll_frame_id,
+ parent.accumulated_external_scroll_offset + external_scroll_offset,
+ );
+
+ let descriptor = di::SpatialTreeItem::ScrollFrame(di::ScrollFrameDescriptor {
+ content_rect,
+ frame_rect: frame_rect.translate(current_offset),
+ parent_space,
+ scroll_frame_id,
+ external_id,
+ external_scroll_offset,
+ scroll_offset_generation,
+ has_scroll_linked_effect,
+ key,
+ });
+
+ self.push_spatial_tree_item(&descriptor);
+
+ scroll_frame_id
+ }
+
+ pub fn define_clip_chain<I>(
+ &mut self,
+ parent: Option<di::ClipChainId>,
+ clips: I,
+ ) -> di::ClipChainId
+ where
+ I: IntoIterator<Item = di::ClipId>,
+ I::IntoIter: ExactSizeIterator + Clone,
+ {
+ let id = self.generate_clip_chain_id();
+ self.push_item(&di::DisplayItem::ClipChain(di::ClipChainItem { id, parent }));
+ self.push_iter(clips);
+ id
+ }
+
+ pub fn define_clip_image_mask(
+ &mut self,
+ spatial_id: di::SpatialId,
+ image_mask: di::ImageMask,
+ points: &[LayoutPoint],
+ fill_rule: di::FillRule,
+ ) -> di::ClipId {
+ let id = self.generate_clip_index();
+
+ let current_offset = self.current_offset(spatial_id);
+
+ let image_mask = di::ImageMask {
+ rect: image_mask.rect.translate(current_offset),
+ ..image_mask
+ };
+
+ let item = di::DisplayItem::ImageMaskClip(di::ImageMaskClipDisplayItem {
+ id,
+ spatial_id,
+ image_mask,
+ fill_rule,
+ });
+
+ // We only need to supply points if there are at least 3, which is the
+ // minimum to specify a polygon. BuiltDisplayListIter.next ensures that points
+ // are cleared between processing other display items, so we'll correctly get
+ // zero points when no SetPoints item has been pushed.
+ if points.len() >= 3 {
+ self.push_item(&di::DisplayItem::SetPoints);
+ self.push_iter(points);
+ }
+ self.push_item(&item);
+ id
+ }
+
+ pub fn define_clip_rect(
+ &mut self,
+ spatial_id: di::SpatialId,
+ clip_rect: LayoutRect,
+ ) -> di::ClipId {
+ let id = self.generate_clip_index();
+
+ let current_offset = self.current_offset(spatial_id);
+ let clip_rect = clip_rect.translate(current_offset);
+
+ let item = di::DisplayItem::RectClip(di::RectClipDisplayItem {
+ id,
+ spatial_id,
+ clip_rect,
+ });
+
+ self.push_item(&item);
+ id
+ }
+
+ pub fn define_clip_rounded_rect(
+ &mut self,
+ spatial_id: di::SpatialId,
+ clip: di::ComplexClipRegion,
+ ) -> di::ClipId {
+ let id = self.generate_clip_index();
+
+ let current_offset = self.current_offset(spatial_id);
+
+ let clip = di::ComplexClipRegion {
+ rect: clip.rect.translate(current_offset),
+ ..clip
+ };
+
+ let item = di::DisplayItem::RoundedRectClip(di::RoundedRectClipDisplayItem {
+ id,
+ spatial_id,
+ clip,
+ });
+
+ self.push_item(&item);
+ id
+ }
+
+ pub fn define_sticky_frame(
+ &mut self,
+ parent_spatial_id: di::SpatialId,
+ frame_rect: LayoutRect,
+ margins: SideOffsets2D<Option<f32>, LayoutPixel>,
+ vertical_offset_bounds: di::StickyOffsetBounds,
+ horizontal_offset_bounds: di::StickyOffsetBounds,
+ previously_applied_offset: LayoutVector2D,
+ key: di::SpatialTreeItemKey,
+ ) -> di::SpatialId {
+ let id = self.generate_spatial_index();
+ let current_offset = self.current_offset(parent_spatial_id);
+ let parent = self.spatial_nodes[parent_spatial_id.0].clone();
+
+ self.add_spatial_node_info(
+ id,
+ parent.accumulated_external_scroll_offset,
+ );
+
+ let descriptor = di::SpatialTreeItem::StickyFrame(di::StickyFrameDescriptor {
+ parent_spatial_id,
+ id,
+ bounds: frame_rect.translate(current_offset),
+ margins,
+ vertical_offset_bounds,
+ horizontal_offset_bounds,
+ previously_applied_offset,
+ key,
+ });
+
+ self.push_spatial_tree_item(&descriptor);
+ id
+ }
+
+ pub fn push_iframe(
+ &mut self,
+ bounds: LayoutRect,
+ clip_rect: LayoutRect,
+ space_and_clip: &di::SpaceAndClipInfo,
+ pipeline_id: PipelineId,
+ ignore_missing_pipeline: bool
+ ) {
+ let current_offset = self.current_offset(space_and_clip.spatial_id);
+ let bounds = bounds.translate(current_offset);
+ let clip_rect = clip_rect.translate(current_offset);
+
+ let item = di::DisplayItem::Iframe(di::IframeDisplayItem {
+ bounds,
+ clip_rect,
+ space_and_clip: *space_and_clip,
+ pipeline_id,
+ ignore_missing_pipeline,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn push_shadow(
+ &mut self,
+ space_and_clip: &di::SpaceAndClipInfo,
+ shadow: di::Shadow,
+ should_inflate: bool,
+ ) {
+ let item = di::DisplayItem::PushShadow(di::PushShadowDisplayItem {
+ space_and_clip: *space_and_clip,
+ shadow,
+ should_inflate,
+ });
+ self.push_item(&item);
+ }
+
+ pub fn pop_all_shadows(&mut self) {
+ self.push_item(&di::DisplayItem::PopAllShadows);
+ }
+
+ pub fn start_item_group(&mut self) {
+ debug_assert!(!self.writing_to_chunk);
+ debug_assert!(self.pending_chunk.is_empty());
+
+ self.writing_to_chunk = true;
+ }
+
+ fn flush_pending_item_group(&mut self, key: di::ItemKey) {
+ // Push RetainedItems-marker to cache_data section.
+ self.push_retained_items(key);
+
+ // Push pending chunk to cache_data section.
+ self.payload.cache_data.append(&mut self.pending_chunk);
+
+ // Push ReuseItems-marker to data section.
+ self.push_reuse_items(key);
+ }
+
+ pub fn finish_item_group(&mut self, key: di::ItemKey) -> bool {
+ debug_assert!(self.writing_to_chunk);
+ self.writing_to_chunk = false;
+
+ if self.pending_chunk.is_empty() {
+ return false;
+ }
+
+ self.flush_pending_item_group(key);
+ true
+ }
+
+ pub fn cancel_item_group(&mut self, discard: bool) {
+ debug_assert!(self.writing_to_chunk);
+ self.writing_to_chunk = false;
+
+ if discard {
+ self.pending_chunk.clear();
+ } else {
+ // Push pending chunk to data section.
+ self.payload.items_data.append(&mut self.pending_chunk);
+ }
+ }
+
+ pub fn push_reuse_items(&mut self, key: di::ItemKey) {
+ self.push_item_to_section(
+ &di::DisplayItem::ReuseItems(key),
+ DisplayListSection::Data
+ );
+ }
+
+ fn push_retained_items(&mut self, key: di::ItemKey) {
+ self.push_item_to_section(
+ &di::DisplayItem::RetainedItems(key),
+ DisplayListSection::CacheData
+ );
+ }
+
+ pub fn set_cache_size(&mut self, cache_size: usize) {
+ self.cache_size = cache_size;
+ }
+
+ pub fn begin(&mut self) {
+ assert_eq!(self.state, BuildState::Idle);
+ self.state = BuildState::Build;
+ self.builder_start_time = precise_time_ns();
+ self.reset();
+ }
+
+ pub fn end(&mut self) -> (PipelineId, BuiltDisplayList) {
+ assert_eq!(self.state, BuildState::Build);
+ assert!(self.save_state.is_none(), "Finalized DisplayListBuilder with a pending save");
+
+ if let Some(content) = self.serialized_content_buffer.take() {
+ println!("-- WebRender display list for {:?} --\n{}",
+ self.pipeline_id, content);
+ }
+
+ // Add `DisplayItem::max_size` zone of zeroes to the end of display list
+ // so there is at least this amount available in the display list during
+ // serialization.
+ ensure_red_zone::<di::DisplayItem>(&mut self.payload.items_data);
+ ensure_red_zone::<di::DisplayItem>(&mut self.payload.cache_data);
+ ensure_red_zone::<di::SpatialTreeItem>(&mut self.payload.spatial_tree);
+
+ // While the first display list after tab-switch can be large, the
+ // following ones are always smaller thanks to interning. We attempt
+ // to reserve the same capacity again, although it may fail. Memory
+ // pressure events will cause us to release our buffers if we ask for
+ // too much. See bug 1531819 for related OOM issues.
+ let next_capacity = DisplayListCapacity {
+ cache_size: self.payload.cache_data.len(),
+ items_size: self.payload.items_data.len(),
+ spatial_tree_size: self.payload.spatial_tree.len(),
+ };
+ let payload = mem::replace(
+ &mut self.payload,
+ DisplayListPayload::new(next_capacity),
+ );
+ let end_time = precise_time_ns();
+
+ self.state = BuildState::Idle;
+
+ (
+ self.pipeline_id,
+ BuiltDisplayList {
+ descriptor: BuiltDisplayListDescriptor {
+ gecko_display_list_type: GeckoDisplayListType::None,
+ builder_start_time: self.builder_start_time,
+ builder_finish_time: end_time,
+ send_start_time: end_time,
+ total_clip_nodes: self.next_clip_index,
+ total_spatial_nodes: self.next_spatial_index,
+ cache_size: self.cache_size,
+ },
+ payload,
+ },
+ )
+ }
+
+ /// Retrieve the current offset to allow converting a stacking context
+ /// relative coordinate to be relative to the owing reference frame,
+ /// also considering any external scroll offset on the provided
+ /// spatial node.
+ fn current_offset(
+ &mut self,
+ spatial_id: di::SpatialId,
+ ) -> LayoutVector2D {
+ // Get the current offset from stacking context <-> reference frame space.
+ let rf_offset = self.rf_mapper.current_offset();
+
+ // Get the external scroll offset, if applicable.
+ let scroll_offset = self.spatial_nodes[spatial_id.0].accumulated_external_scroll_offset;
+
+ rf_offset + scroll_offset
+ }
+
+ /// Add info about a spatial node that is needed during DL building.
+ fn add_spatial_node_info(
+ &mut self,
+ id: di::SpatialId,
+ accumulated_external_scroll_offset: LayoutVector2D,
+ ) {
+ self.spatial_nodes.resize(id.0 + 1, SpatialNodeInfo::identity());
+
+ let info = &mut self.spatial_nodes[id.0];
+ info.accumulated_external_scroll_offset = accumulated_external_scroll_offset;
+ }
+}
+
+fn iter_spatial_tree<F>(spatial_tree: &[u8], mut f: F) where F: FnMut(&di::SpatialTreeItem) {
+ let mut src = spatial_tree;
+ let mut item = di::SpatialTreeItem::Invalid;
+
+ while src.len() > di::SpatialTreeItem::max_size() {
+ src = peek_from_slice(src, &mut item);
+ f(&item);
+ }
+}
+
+/// The offset stack for a given reference frame.
+#[derive(Clone)]
+struct ReferenceFrameState {
+ /// A stack of current offsets from the current reference frame scope.
+ offsets: Vec<LayoutVector2D>,
+}
+
+/// Maps from stacking context layout coordinates into reference frame
+/// relative coordinates.
+#[derive(Clone)]
+pub struct ReferenceFrameMapper {
+ /// A stack of reference frame scopes.
+ frames: Vec<ReferenceFrameState>,
+}
+
+impl ReferenceFrameMapper {
+ pub fn new() -> Self {
+ ReferenceFrameMapper {
+ frames: vec![
+ ReferenceFrameState {
+ offsets: vec![
+ LayoutVector2D::zero(),
+ ],
+ }
+ ],
+ }
+ }
+
+ /// Push a new scope. This resets the current offset to zero, and is
+ /// used when a new reference frame or iframe is pushed.
+ pub fn push_scope(&mut self) {
+ self.frames.push(ReferenceFrameState {
+ offsets: vec![
+ LayoutVector2D::zero(),
+ ],
+ });
+ }
+
+ /// Pop a reference frame scope off the stack.
+ pub fn pop_scope(&mut self) {
+ self.frames.pop().unwrap();
+ }
+
+ /// Push a new offset for the current scope. This is used when
+ /// a new stacking context is pushed.
+ pub fn push_offset(&mut self, offset: LayoutVector2D) {
+ let frame = self.frames.last_mut().unwrap();
+ let current_offset = *frame.offsets.last().unwrap();
+ frame.offsets.push(current_offset + offset);
+ }
+
+ /// Pop a local stacking context offset from the current scope.
+ pub fn pop_offset(&mut self) {
+ let frame = self.frames.last_mut().unwrap();
+ frame.offsets.pop().unwrap();
+ }
+
+ /// Retrieve the current offset to allow converting a stacking context
+ /// relative coordinate to be relative to the owing reference frame.
+ /// TODO(gw): We could perhaps have separate coordinate spaces for this,
+ /// however that's going to either mean a lot of changes to
+ /// public API code, or a lot of changes to internal code.
+ /// Before doing that, we should revisit how Gecko would
+ /// prefer to provide coordinates.
+ /// TODO(gw): For now, this includes only the reference frame relative
+ /// offset. Soon, we will expand this to include the initial
+ /// scroll offsets that are now available on scroll nodes. This
+ /// will allow normalizing the coordinates even between display
+ /// lists where APZ has scrolled the content.
+ pub fn current_offset(&self) -> LayoutVector2D {
+ *self.frames.last().unwrap().offsets.last().unwrap()
+ }
+}
diff --git a/gfx/wr/webrender_api/src/font.rs b/gfx/wr/webrender_api/src/font.rs
new file mode 100644
index 0000000000..d4f3057a7c
--- /dev/null
+++ b/gfx/wr/webrender_api/src/font.rs
@@ -0,0 +1,442 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use peek_poke::PeekPoke;
+use std::cmp::Ordering;
+use std::hash::{Hash, Hasher};
+#[cfg(not(target_os = "macos"))]
+use std::path::PathBuf;
+use std::sync::Arc;
+// local imports
+use crate::IdNamespace;
+use crate::channel::Sender;
+use crate::units::LayoutPoint;
+
+/// Hashable floating-point storage for font size.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, Deserialize, Serialize)]
+pub struct FontSize(pub f32);
+
+impl Ord for FontSize {
+ fn cmp(&self, other: &FontSize) -> Ordering {
+ self.partial_cmp(other).unwrap_or(Ordering::Equal)
+ }
+}
+
+impl Eq for FontSize {}
+
+impl Hash for FontSize {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.0.to_bits().hash(state);
+ }
+}
+
+impl From<f32> for FontSize {
+ fn from(size: f32) -> Self { FontSize(size) }
+}
+
+impl From<FontSize> for f32 {
+ fn from(size: FontSize) -> Self { size.0 }
+}
+
+impl FontSize {
+ pub fn zero() -> Self { FontSize(0.0) }
+
+ pub fn from_f32_px(size: f32) -> Self { FontSize(size) }
+
+ pub fn to_f32_px(&self) -> f32 { self.0 }
+
+ pub fn from_f64_px(size: f64) -> Self { FontSize(size as f32) }
+
+ pub fn to_f64_px(&self) -> f64 { self.0 as f64 }
+}
+
+#[cfg(not(target_os = "macos"))]
+#[derive(Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct NativeFontHandle {
+ pub path: PathBuf,
+ pub index: u32,
+}
+
+#[cfg(target_os = "macos")]
+#[derive(Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct NativeFontHandle {
+ pub name: String,
+ pub path: String,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Deserialize, Serialize, Debug)]
+pub struct GlyphDimensions {
+ pub left: i32,
+ pub top: i32,
+ pub width: i32,
+ pub height: i32,
+ pub advance: f32,
+}
+
+pub struct GlyphDimensionRequest {
+ pub key: FontInstanceKey,
+ pub glyph_indices: Vec<GlyphIndex>,
+ pub sender: Sender<Vec<Option<GlyphDimensions>>>,
+}
+
+pub struct GlyphIndexRequest {
+ pub key: FontKey,
+ pub text: String,
+ pub sender: Sender<Vec<Option<u32>>>,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, Ord, PartialOrd)]
+pub struct FontKey(pub IdNamespace, pub u32);
+
+impl FontKey {
+ pub fn new(namespace: IdNamespace, key: u32) -> FontKey {
+ FontKey(namespace, key)
+ }
+}
+
+/// Container for the raw data describing a font. This might be a stream of
+/// bytes corresponding to a downloaded font, or a handle to a native font from
+/// the operating system.
+///
+/// Note that fonts need to be instantiated before being used, which involves
+/// assigning size and various other options. The word 'template' here is
+/// intended to distinguish this data from instance-specific data.
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub enum FontTemplate {
+ Raw(Arc<Vec<u8>>, u32),
+ Native(NativeFontHandle),
+}
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, Eq, MallocSizeOf, PartialEq, Serialize, Deserialize, Ord, PartialOrd, PeekPoke)]
+pub enum FontRenderMode {
+ Mono = 0,
+ Alpha,
+ Subpixel,
+}
+
+impl Default for FontRenderMode {
+ fn default() -> Self {
+ FontRenderMode::Mono
+ }
+}
+
+impl FontRenderMode {
+ // Combine two font render modes such that the lesser amount of AA limits the AA of the result.
+ pub fn limit_by(self, other: FontRenderMode) -> FontRenderMode {
+ match (self, other) {
+ (FontRenderMode::Subpixel, _) | (_, FontRenderMode::Mono) => other,
+ _ => self,
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialOrd, Deserialize, Serialize)]
+pub struct FontVariation {
+ pub tag: u32,
+ pub value: f32,
+}
+
+impl Ord for FontVariation {
+ fn cmp(&self, other: &FontVariation) -> Ordering {
+ self.tag.cmp(&other.tag)
+ .then(self.value.to_bits().cmp(&other.value.to_bits()))
+ }
+}
+
+impl PartialEq for FontVariation {
+ fn eq(&self, other: &FontVariation) -> bool {
+ self.tag == other.tag &&
+ self.value.to_bits() == other.value.to_bits()
+ }
+}
+
+impl Eq for FontVariation {}
+
+impl Hash for FontVariation {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.tag.hash(state);
+ self.value.to_bits().hash(state);
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, PartialEq, PartialOrd, Ord, Serialize, PeekPoke)]
+pub struct GlyphOptions {
+ pub render_mode: FontRenderMode,
+ pub flags: FontInstanceFlags,
+}
+
+impl Default for GlyphOptions {
+ fn default() -> Self {
+ GlyphOptions {
+ render_mode: FontRenderMode::Subpixel,
+ flags: FontInstanceFlags::empty(),
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Deserialize, MallocSizeOf, Serialize, PeekPoke)]
+pub struct FontInstanceFlags(u32);
+
+bitflags! {
+ impl FontInstanceFlags: u32 {
+ // Common flags
+ // Use native synthetic bold, if supported.
+ const SYNTHETIC_BOLD = 1 << 1;
+ const EMBEDDED_BITMAPS = 1 << 2;
+ const SUBPIXEL_BGR = 1 << 3;
+ const TRANSPOSE = 1 << 4;
+ const FLIP_X = 1 << 5;
+ const FLIP_Y = 1 << 6;
+ const SUBPIXEL_POSITION = 1 << 7;
+ const VERTICAL = 1 << 8;
+ // Explicitly use multi-strike bold emulation.
+ const MULTISTRIKE_BOLD = 1 << 9;
+
+ // Internal flags
+ const TRANSFORM_GLYPHS = 1 << 12;
+ const TEXTURE_PADDING = 1 << 13;
+
+ // Windows flags
+ const FORCE_GDI = 1 << 16;
+ const FORCE_SYMMETRIC = 1 << 17;
+ const NO_SYMMETRIC = 1 << 18;
+
+ // Mac flags
+ const FONT_SMOOTHING = 1 << 16;
+
+ // FreeType flags
+ const FORCE_AUTOHINT = 1 << 16;
+ const NO_AUTOHINT = 1 << 17;
+ const VERTICAL_LAYOUT = 1 << 18;
+ const LCD_VERTICAL = 1 << 19;
+ }
+}
+
+impl core::fmt::Debug for FontInstanceFlags {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.is_empty() {
+ write!(f, "{:#x}", Self::empty().bits())
+ } else {
+ bitflags::parser::to_writer(self, f)
+ }
+ }
+}
+
+impl Default for FontInstanceFlags {
+ #[cfg(target_os = "windows")]
+ fn default() -> FontInstanceFlags {
+ FontInstanceFlags::SUBPIXEL_POSITION
+ }
+
+ #[cfg(target_os = "macos")]
+ fn default() -> FontInstanceFlags {
+ FontInstanceFlags::SUBPIXEL_POSITION |
+ FontInstanceFlags::FONT_SMOOTHING
+ }
+
+ #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+ fn default() -> FontInstanceFlags {
+ FontInstanceFlags::SUBPIXEL_POSITION
+ }
+}
+
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct SyntheticItalics {
+ // Angle in degrees (-90..90) for synthetic italics in 8.8 fixed-point.
+ pub angle: i16,
+}
+
+impl SyntheticItalics {
+ pub const ANGLE_SCALE: f32 = 256.0;
+
+ pub fn from_degrees(degrees: f32) -> Self {
+ SyntheticItalics { angle: (degrees.max(-89.0).min(89.0) * Self::ANGLE_SCALE) as i16 }
+ }
+
+ pub fn to_degrees(self) -> f32 {
+ self.angle as f32 / Self::ANGLE_SCALE
+ }
+
+ pub fn to_radians(self) -> f32 {
+ self.to_degrees().to_radians()
+ }
+
+ pub fn to_skew(self) -> f32 {
+ self.to_radians().tan()
+ }
+
+ pub fn enabled() -> Self {
+ Self::from_degrees(14.0)
+ }
+
+ pub fn disabled() -> Self {
+ SyntheticItalics { angle: 0 }
+ }
+
+ pub fn is_enabled(self) -> bool {
+ self.angle != 0
+ }
+}
+
+impl Default for SyntheticItalics {
+ fn default() -> Self {
+ SyntheticItalics::disabled()
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct FontInstanceOptions {
+ pub render_mode: FontRenderMode,
+ pub flags: FontInstanceFlags,
+ pub synthetic_italics: SyntheticItalics,
+}
+
+impl Default for FontInstanceOptions {
+ fn default() -> FontInstanceOptions {
+ FontInstanceOptions {
+ render_mode: FontRenderMode::Subpixel,
+ flags: Default::default(),
+ synthetic_italics: SyntheticItalics::disabled(),
+ }
+ }
+}
+
+#[cfg(target_os = "windows")]
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct FontInstancePlatformOptions {
+ pub gamma: u16, // percent
+ pub contrast: u8, // percent
+ pub cleartype_level: u8, // percent
+}
+
+#[cfg(target_os = "windows")]
+impl Default for FontInstancePlatformOptions {
+ fn default() -> FontInstancePlatformOptions {
+ FontInstancePlatformOptions {
+ gamma: 180, // Default DWrite gamma
+ contrast: 100,
+ cleartype_level: 100,
+ }
+ }
+}
+
+#[cfg(target_os = "macos")]
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct FontInstancePlatformOptions {
+ pub unused: u32,
+}
+
+#[cfg(target_os = "macos")]
+impl Default for FontInstancePlatformOptions {
+ fn default() -> FontInstancePlatformOptions {
+ FontInstancePlatformOptions {
+ unused: 0,
+ }
+ }
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub enum FontLCDFilter {
+ None,
+ Default,
+ Light,
+ Legacy,
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub enum FontHinting {
+ None,
+ Mono,
+ Light,
+ Normal,
+ LCD,
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Hash, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct FontInstancePlatformOptions {
+ pub lcd_filter: FontLCDFilter,
+ pub hinting: FontHinting,
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+impl Default for FontInstancePlatformOptions {
+ fn default() -> FontInstancePlatformOptions {
+ FontInstancePlatformOptions {
+ lcd_filter: FontLCDFilter::Default,
+ hinting: FontHinting::LCD,
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq, Ord, PartialOrd, MallocSizeOf, PeekPoke)]
+#[derive(Deserialize, Serialize)]
+pub struct FontInstanceKey(pub IdNamespace, pub u32);
+
+impl FontInstanceKey {
+ pub fn new(namespace: IdNamespace, key: u32) -> FontInstanceKey {
+ FontInstanceKey(namespace, key)
+ }
+}
+
+/// Data corresponding to an instantiation of a font, with size and
+/// other options specified.
+///
+/// Note that the actual font is stored out-of-band in `FontTemplate`.
+#[derive(Clone)]
+pub struct FontInstanceData {
+ pub font_key: FontKey,
+ pub size: f32,
+ pub options: Option<FontInstanceOptions>,
+ pub platform_options: Option<FontInstancePlatformOptions>,
+ pub variations: Vec<FontVariation>,
+}
+
+pub type GlyphIndex = u32;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct GlyphInstance {
+ pub index: GlyphIndex,
+ pub point: LayoutPoint,
+}
+
+impl Default for GlyphInstance {
+ fn default() -> Self {
+ GlyphInstance {
+ index: 0,
+ point: LayoutPoint::zero(),
+ }
+ }
+}
+
+impl Eq for GlyphInstance {}
+
+#[cfg_attr(feature = "cargo-clippy", allow(clippy::derive_hash_xor_eq))]
+impl Hash for GlyphInstance {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ // Note: this is inconsistent with the Eq impl for -0.0 (don't care).
+ self.index.hash(state);
+ self.point.x.to_bits().hash(state);
+ self.point.y.to_bits().hash(state);
+ }
+}
diff --git a/gfx/wr/webrender_api/src/gradient_builder.rs b/gfx/wr/webrender_api/src/gradient_builder.rs
new file mode 100644
index 0000000000..6347396f79
--- /dev/null
+++ b/gfx/wr/webrender_api/src/gradient_builder.rs
@@ -0,0 +1,180 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+use crate::display_item as di;
+use crate::units::*;
+
+
+/// Construct a gradient to be used in display lists.
+///
+/// Each gradient needs at least two stops.
+pub struct GradientBuilder {
+ stops: Vec<di::GradientStop>,
+}
+
+impl GradientBuilder {
+ /// Create a new gradient builder.
+ pub fn new() -> Self {
+ GradientBuilder {
+ stops: Vec::new(),
+ }
+ }
+
+ /// Create a gradient builder with a list of stops.
+ pub fn with_stops(stops: Vec<di::GradientStop>) -> GradientBuilder {
+ GradientBuilder { stops }
+ }
+
+ /// Push an additional stop for the gradient.
+ pub fn push(&mut self, stop: di::GradientStop) {
+ self.stops.push(stop);
+ }
+
+ /// Get a reference to the list of stops.
+ pub fn stops(&self) -> &[di::GradientStop] {
+ self.stops.as_ref()
+ }
+
+ /// Return the gradient stops vector.
+ pub fn into_stops(self) -> Vec<di::GradientStop> {
+ self.stops
+ }
+
+ /// Produce a linear gradient, normalize the stops.
+ pub fn gradient(
+ &mut self,
+ start_point: LayoutPoint,
+ end_point: LayoutPoint,
+ extend_mode: di::ExtendMode,
+ ) -> di::Gradient {
+ let (start_offset, end_offset) = self.normalize(extend_mode);
+ let start_to_end = end_point - start_point;
+
+ di::Gradient {
+ start_point: start_point + start_to_end * start_offset,
+ end_point: start_point + start_to_end * end_offset,
+ extend_mode,
+ }
+ }
+
+ /// Produce a radial gradient, normalize the stops.
+ ///
+ /// Will replace the gradient with a single color
+ /// if the radius negative.
+ pub fn radial_gradient(
+ &mut self,
+ center: LayoutPoint,
+ radius: LayoutSize,
+ extend_mode: di::ExtendMode,
+ ) -> di::RadialGradient {
+ if radius.width <= 0.0 || radius.height <= 0.0 {
+ // The shader cannot handle a non positive radius. So
+ // reuse the stops vector and construct an equivalent
+ // gradient.
+ let last_color = self.stops.last().unwrap().color;
+
+ self.stops.clear();
+ self.stops.push(di::GradientStop { offset: 0.0, color: last_color, });
+ self.stops.push(di::GradientStop { offset: 1.0, color: last_color, });
+
+ return di::RadialGradient {
+ center,
+ radius: LayoutSize::new(1.0, 1.0),
+ start_offset: 0.0,
+ end_offset: 1.0,
+ extend_mode,
+ };
+ }
+
+ let (start_offset, end_offset) =
+ self.normalize(extend_mode);
+
+ di::RadialGradient {
+ center,
+ radius,
+ start_offset,
+ end_offset,
+ extend_mode,
+ }
+ }
+
+ /// Produce a conic gradient, normalize the stops.
+ pub fn conic_gradient(
+ &mut self,
+ center: LayoutPoint,
+ angle: f32,
+ extend_mode: di::ExtendMode,
+ ) -> di::ConicGradient {
+ let (start_offset, end_offset) =
+ self.normalize(extend_mode);
+
+ di::ConicGradient {
+ center,
+ angle,
+ start_offset,
+ end_offset,
+ extend_mode,
+ }
+ }
+
+ /// Gradients can be defined with stops outside the range of [0, 1]
+ /// when this happens the gradient needs to be normalized by adjusting
+ /// the gradient stops and gradient line into an equivalent gradient
+ /// with stops in the range [0, 1]. this is done by moving the beginning
+ /// of the gradient line to where stop[0] and the end of the gradient line
+ /// to stop[n-1]. this function adjusts the stops in place, and returns
+ /// the amount to adjust the gradient line start and stop.
+ fn normalize(&mut self, extend_mode: di::ExtendMode) -> (f32, f32) {
+ let stops = &mut self.stops;
+ assert!(stops.len() >= 2);
+
+ let first = *stops.first().unwrap();
+ let last = *stops.last().unwrap();
+
+ // Express the assertion so that if one of the offsets is NaN, we don't panic
+ // and instead take the branch that handles degenerate gradients.
+ assert!(!(first.offset > last.offset));
+
+ let stops_delta = last.offset - first.offset;
+
+ if stops_delta > 0.000001 {
+ for stop in stops {
+ stop.offset = (stop.offset - first.offset) / stops_delta;
+ }
+
+ (first.offset, last.offset)
+ } else {
+ // We have a degenerate gradient and can't accurately transform the stops
+ // what happens here depends on the repeat behavior, but in any case
+ // we reconstruct the gradient stops to something simpler and equivalent
+ stops.clear();
+
+ match extend_mode {
+ di::ExtendMode::Clamp => {
+ // This gradient is two colors split at the offset of the stops,
+ // so create a gradient with two colors split at 0.5 and adjust
+ // the gradient line so 0.5 is at the offset of the stops
+ stops.push(di::GradientStop { color: first.color, offset: 0.0, });
+ stops.push(di::GradientStop { color: first.color, offset: 0.5, });
+ stops.push(di::GradientStop { color: last.color, offset: 0.5, });
+ stops.push(di::GradientStop { color: last.color, offset: 1.0, });
+
+ let offset = last.offset;
+
+ (offset - 0.5, offset + 0.5)
+ }
+ di::ExtendMode::Repeat => {
+ // A repeating gradient with stops that are all in the same
+ // position should just display the last color. I believe the
+ // spec says that it should be the average color of the gradient,
+ // but this matches what Gecko and Blink does
+ stops.push(di::GradientStop { color: last.color, offset: 0.0, });
+ stops.push(di::GradientStop { color: last.color, offset: 1.0, });
+
+ (0.0, 1.0)
+ }
+ }
+ }
+ }
+}
diff --git a/gfx/wr/webrender_api/src/image.rs b/gfx/wr/webrender_api/src/image.rs
new file mode 100644
index 0000000000..903b127782
--- /dev/null
+++ b/gfx/wr/webrender_api/src/image.rs
@@ -0,0 +1,584 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+#![deny(missing_docs)]
+
+use euclid::{size2, Box2D, num::Zero};
+use peek_poke::PeekPoke;
+use std::ops::{Add, Sub};
+use std::sync::Arc;
+// local imports
+use crate::{IdNamespace, TileSize};
+use crate::font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
+use crate::units::*;
+
+/// The default tile size for blob images and regular images larger than
+/// the maximum texture size.
+pub const DEFAULT_TILE_SIZE: TileSize = 512;
+
+/// An opaque identifier describing an image registered with WebRender.
+/// This is used as a handle to reference images, and is used as the
+/// hash map key for the actual image storage in the `ResourceCache`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct ImageKey(pub IdNamespace, pub u32);
+
+impl Default for ImageKey {
+ fn default() -> Self {
+ ImageKey::DUMMY
+ }
+}
+
+impl ImageKey {
+ /// Placeholder Image key, used to represent None.
+ pub const DUMMY: Self = ImageKey(IdNamespace(0), 0);
+
+ /// Mints a new ImageKey. The given ID must be unique.
+ pub fn new(namespace: IdNamespace, key: u32) -> Self {
+ ImageKey(namespace, key)
+ }
+}
+
+/// An opaque identifier describing a blob image registered with WebRender.
+/// This is used as a handle to reference blob images, and can be used as an
+/// image in display items.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub struct BlobImageKey(pub ImageKey);
+
+impl BlobImageKey {
+ /// Interpret this blob image as an image for a display item.
+ pub fn as_image(self) -> ImageKey {
+ self.0
+ }
+}
+
+/// An arbitrary identifier for an external image provided by the
+/// application. It must be a unique identifier for each external
+/// image.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct ExternalImageId(pub u64);
+
+/// The source for an external image.
+pub enum ExternalImageSource<'a> {
+ /// A raw pixel buffer.
+ RawData(&'a [u8]),
+ /// A gl::GLuint texture handle.
+ NativeTexture(u32),
+ /// An invalid source.
+ Invalid,
+}
+
+/// The data that an external client should provide about
+/// an external image. For instance, if providing video frames,
+/// the application could call wr.render() whenever a new
+/// video frame is ready. Note that the UV coords are supplied
+/// in texel-space!
+pub struct ExternalImage<'a> {
+ /// UV coordinates for the image.
+ pub uv: TexelRect,
+ /// The source for this image's contents.
+ pub source: ExternalImageSource<'a>,
+}
+
+/// The interfaces that an application can implement to support providing
+/// external image buffers.
+/// When the application passes an external image to WR, it should keep that
+/// external image life time. People could check the epoch id in RenderNotifier
+/// at the client side to make sure that the external image is not used by WR.
+/// Then, do the clean up for that external image.
+pub trait ExternalImageHandler {
+ /// Lock the external image. Then, WR could start to read the image content.
+ /// The WR client should not change the image content until the unlock()
+ /// call.
+ fn lock(&mut self, key: ExternalImageId, channel_index: u8) -> ExternalImage;
+ /// Unlock the external image. WR should not read the image content
+ /// after this call.
+ fn unlock(&mut self, key: ExternalImageId, channel_index: u8);
+}
+
+/// Specifies the type of texture target in driver terms.
+#[repr(u8)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
+pub enum ImageBufferKind {
+ /// Standard texture. This maps to GL_TEXTURE_2D in OpenGL.
+ Texture2D = 0,
+ /// Rectangle texture. This maps to GL_TEXTURE_RECTANGLE in OpenGL. This
+ /// is similar to a standard texture, with a few subtle differences
+ /// (no mipmaps, non-power-of-two dimensions, different coordinate space)
+ /// that make it useful for representing the kinds of textures we use
+ /// in WebRender. See https://www.khronos.org/opengl/wiki/Rectangle_Texture
+ /// for background on Rectangle textures.
+ TextureRect = 1,
+ /// External texture. This maps to GL_TEXTURE_EXTERNAL_OES in OpenGL, which
+ /// is an extension. This is used for image formats that OpenGL doesn't
+ /// understand, particularly YUV. See
+ /// https://www.khronos.org/registry/OpenGL/extensions/OES/OES_EGL_image_external.txt
+ TextureExternal = 2,
+ /// External texture which is forced to be converted from YUV to RGB using BT709 colorspace.
+ /// This maps to GL_TEXTURE_EXTERNAL_OES in OpenGL, using the EXT_YUV_TARGET extension.
+ /// https://registry.khronos.org/OpenGL/extensions/EXT/EXT_YUV_target.txt
+ TextureExternalBT709 = 3,
+}
+
+/// Storage format identifier for externally-managed images.
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub enum ExternalImageType {
+ /// The image is texture-backed.
+ TextureHandle(ImageBufferKind),
+ /// The image is heap-allocated by the embedding.
+ Buffer,
+}
+
+/// Descriptor for external image resources. See `ImageData`.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct ExternalImageData {
+ /// The identifier of this external image, provided by the embedding.
+ pub id: ExternalImageId,
+ /// For multi-plane images (i.e. YUV), indicates the plane of the
+ /// original image that this struct represents. 0 for single-plane images.
+ pub channel_index: u8,
+ /// Storage format identifier.
+ pub image_type: ExternalImageType,
+}
+
+/// Specifies the format of a series of pixels, in driver terms.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub enum ImageFormat {
+ /// One-channel, byte storage. The "red" doesn't map to the color
+ /// red per se, and is just the way that OpenGL has historically referred
+ /// to single-channel buffers.
+ R8 = 1,
+ /// One-channel, short storage
+ R16 = 2,
+ /// Four channels, byte storage.
+ BGRA8 = 3,
+ /// Four channels, float storage.
+ RGBAF32 = 4,
+ /// Two-channels, byte storage. Similar to `R8`, this just means
+ /// "two channels" rather than "red and green".
+ RG8 = 5,
+ /// Two-channels, short storage. Similar to `R16`, this just means
+ /// "two channels" rather than "red and green".
+ RG16 = 6,
+
+ /// Four channels, signed integer storage.
+ RGBAI32 = 7,
+ /// Four channels, byte storage.
+ RGBA8 = 8,
+}
+
+impl ImageFormat {
+ /// Returns the number of bytes per pixel for the given format.
+ pub fn bytes_per_pixel(self) -> i32 {
+ match self {
+ ImageFormat::R8 => 1,
+ ImageFormat::R16 => 2,
+ ImageFormat::BGRA8 => 4,
+ ImageFormat::RGBAF32 => 16,
+ ImageFormat::RG8 => 2,
+ ImageFormat::RG16 => 4,
+ ImageFormat::RGBAI32 => 16,
+ ImageFormat::RGBA8 => 4,
+ }
+ }
+}
+
+/// Specifies the color depth of an image. Currently only used for YUV images.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum ColorDepth {
+ /// 8 bits image (most common)
+ Color8,
+ /// 10 bits image
+ Color10,
+ /// 12 bits image
+ Color12,
+ /// 16 bits image
+ Color16,
+}
+
+impl Default for ColorDepth {
+ fn default() -> Self {
+ ColorDepth::Color8
+ }
+}
+
+impl ColorDepth {
+ /// Return the numerical bit depth value for the type.
+ pub fn bit_depth(self) -> u32 {
+ match self {
+ ColorDepth::Color8 => 8,
+ ColorDepth::Color10 => 10,
+ ColorDepth::Color12 => 12,
+ ColorDepth::Color16 => 16,
+ }
+ }
+ /// 10 and 12 bits images are encoded using 16 bits integer, we need to
+ /// rescale the 10 or 12 bits value to extend to 16 bits.
+ pub fn rescaling_factor(self) -> f32 {
+ match self {
+ ColorDepth::Color8 => 1.0,
+ ColorDepth::Color10 => 64.0,
+ ColorDepth::Color12 => 16.0,
+ ColorDepth::Color16 => 1.0,
+ }
+ }
+}
+
+bitflags! {
+ /// Various flags that are part of an image descriptor.
+ #[derive(Debug, Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Deserialize, Serialize)]
+ pub struct ImageDescriptorFlags: u32 {
+ /// Whether this image is opaque, or has an alpha channel. Avoiding blending
+ /// for opaque surfaces is an important optimization.
+ const IS_OPAQUE = 1;
+ /// Whether to allow the driver to automatically generate mipmaps. If images
+ /// are already downscaled appropriately, mipmap generation can be wasted
+ /// work, and cause performance problems on some cards/drivers.
+ ///
+ /// See https://github.com/servo/webrender/pull/2555/
+ const ALLOW_MIPMAPS = 2;
+ }
+}
+
+/// Metadata (but not storage) describing an image In WebRender.
+#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct ImageDescriptor {
+ /// Format of the image data.
+ pub format: ImageFormat,
+ /// Width and length of the image data, in pixels.
+ pub size: DeviceIntSize,
+ /// The number of bytes from the start of one row to the next. If non-None,
+ /// `compute_stride` will return this value, otherwise it returns
+ /// `width * bpp`. Different source of images have different alignment
+ /// constraints for rows, so the stride isn't always equal to width * bpp.
+ pub stride: Option<i32>,
+ /// Offset in bytes of the first pixel of this image in its backing buffer.
+ /// This is used for tiling, wherein WebRender extracts chunks of input images
+ /// in order to cache, manipulate, and render them individually. This offset
+ /// tells the texture upload machinery where to find the bytes to upload for
+ /// this tile. Non-tiled images generally set this to zero.
+ pub offset: i32,
+ /// Various bool flags related to this descriptor.
+ pub flags: ImageDescriptorFlags,
+}
+
+impl ImageDescriptor {
+ /// Mints a new ImageDescriptor.
+ pub fn new(
+ width: i32,
+ height: i32,
+ format: ImageFormat,
+ flags: ImageDescriptorFlags,
+ ) -> Self {
+ ImageDescriptor {
+ size: size2(width, height),
+ format,
+ stride: None,
+ offset: 0,
+ flags,
+ }
+ }
+
+ /// Returns the stride, either via an explicit stride stashed on the object
+ /// or by the default computation.
+ pub fn compute_stride(&self) -> i32 {
+ self.stride.unwrap_or(self.size.width * self.format.bytes_per_pixel())
+ }
+
+ /// Computes the total size of the image, in bytes.
+ pub fn compute_total_size(&self) -> i32 {
+ self.compute_stride() * self.size.height
+ }
+
+ /// Computes the bounding rectangle for the image, rooted at (0, 0).
+ pub fn full_rect(&self) -> DeviceIntRect {
+ DeviceIntRect::from_origin_and_size(
+ DeviceIntPoint::zero(),
+ self.size,
+ )
+ }
+
+ /// Returns true if this descriptor is opaque
+ pub fn is_opaque(&self) -> bool {
+ self.flags.contains(ImageDescriptorFlags::IS_OPAQUE)
+ }
+
+ /// Returns true if this descriptor allows mipmaps
+ pub fn allow_mipmaps(&self) -> bool {
+ self.flags.contains(ImageDescriptorFlags::ALLOW_MIPMAPS)
+ }
+}
+
+/// Represents the backing store of an arbitrary series of pixels for display by
+/// WebRender. This storage can take several forms.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum ImageData {
+ /// A simple series of bytes, provided by the embedding and owned by WebRender.
+ /// The format is stored out-of-band, currently in ImageDescriptor.
+ Raw(#[serde(with = "serde_image_data_raw")] Arc<Vec<u8>>),
+ /// An image owned by the embedding, and referenced by WebRender. This may
+ /// take the form of a texture or a heap-allocated buffer.
+ External(ExternalImageData),
+}
+
+mod serde_image_data_raw {
+ extern crate serde_bytes;
+
+ use std::sync::Arc;
+ use serde::{Deserializer, Serializer};
+
+ pub fn serialize<S: Serializer>(bytes: &Arc<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error> {
+ serde_bytes::serialize(bytes.as_slice(), serializer)
+ }
+
+ pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Arc<Vec<u8>>, D::Error> {
+ serde_bytes::deserialize(deserializer).map(Arc::new)
+ }
+}
+
+impl ImageData {
+ /// Mints a new raw ImageData, taking ownership of the bytes.
+ pub fn new(bytes: Vec<u8>) -> Self {
+ ImageData::Raw(Arc::new(bytes))
+ }
+
+ /// Mints a new raw ImageData from Arc-ed bytes.
+ pub fn new_shared(bytes: Arc<Vec<u8>>) -> Self {
+ ImageData::Raw(bytes)
+ }
+}
+
+/// The resources exposed by the resource cache available for use by the blob rasterizer.
+pub trait BlobImageResources {
+ /// Returns the `FontTemplate` for the given key.
+ fn get_font_data(&self, key: FontKey) -> Option<FontTemplate>;
+ /// Returns the `FontInstanceData` for the given key, if found.
+ fn get_font_instance_data(&self, key: FontInstanceKey) -> Option<FontInstanceData>;
+}
+
+/// A handler on the render backend that can create rasterizer objects which will
+/// be sent to the scene builder thread to execute the rasterization.
+///
+/// The handler is responsible for collecting resources, managing/updating blob commands
+/// and creating the rasterizer objects, but isn't expected to do any rasterization itself.
+pub trait BlobImageHandler: Send {
+ /// Creates a snapshot of the current state of blob images in the handler.
+ fn create_blob_rasterizer(&mut self) -> Box<dyn AsyncBlobImageRasterizer>;
+
+ /// Creates an empty blob handler of the same type.
+ ///
+ /// This is used to allow creating new API endpoints with blob handlers installed on them.
+ fn create_similar(&self) -> Box<dyn BlobImageHandler>;
+
+ /// A hook to let the blob image handler update any state related to resources that
+ /// are not bundled in the blob recording itself.
+ fn prepare_resources(
+ &mut self,
+ services: &dyn BlobImageResources,
+ requests: &[BlobImageParams],
+ );
+
+ /// Register a blob image.
+ fn add(&mut self, key: BlobImageKey, data: Arc<BlobImageData>, visible_rect: &DeviceIntRect,
+ tile_size: TileSize);
+
+ /// Update an already registered blob image.
+ fn update(&mut self, key: BlobImageKey, data: Arc<BlobImageData>, visible_rect: &DeviceIntRect,
+ dirty_rect: &BlobDirtyRect);
+
+ /// Delete an already registered blob image.
+ fn delete(&mut self, key: BlobImageKey);
+
+ /// A hook to let the handler clean up any state related to a font which the resource
+ /// cache is about to delete.
+ fn delete_font(&mut self, key: FontKey);
+
+ /// A hook to let the handler clean up any state related to a font instance which the
+ /// resource cache is about to delete.
+ fn delete_font_instance(&mut self, key: FontInstanceKey);
+
+ /// A hook to let the handler clean up any state related a given namespace before the
+ /// resource cache deletes them.
+ fn clear_namespace(&mut self, namespace: IdNamespace);
+
+ /// Whether to allow rendering blobs on multiple threads.
+ fn enable_multithreading(&mut self, enable: bool);
+}
+
+/// A group of rasterization requests to execute synchronously on the scene builder thread.
+pub trait AsyncBlobImageRasterizer : Send {
+ /// Rasterize the requests.
+ ///
+ /// Gecko uses te priority hint to schedule work in a way that minimizes the risk
+ /// of high priority work being blocked by (or enqued behind) low priority work.
+ fn rasterize(
+ &mut self,
+ requests: &[BlobImageParams],
+ low_priority: bool
+ ) -> Vec<(BlobImageRequest, BlobImageResult)>;
+}
+
+
+/// Input parameters for the BlobImageRasterizer.
+#[derive(Copy, Clone, Debug)]
+pub struct BlobImageParams {
+ /// A key that identifies the blob image rasterization request.
+ pub request: BlobImageRequest,
+ /// Description of the format of the blob's output image.
+ pub descriptor: BlobImageDescriptor,
+ /// An optional sub-rectangle of the image to avoid re-rasterizing
+ /// the entire image when only a portion is updated.
+ ///
+ /// If set to None the entire image is rasterized.
+ pub dirty_rect: BlobDirtyRect,
+}
+
+/// The possible states of a Dirty rect.
+///
+/// This exists because people kept getting confused with `Option<Box2D>`.
+#[derive(Debug, Serialize, Deserialize)]
+pub enum DirtyRect<T: Copy, U> {
+ /// Everything is Dirty, equivalent to Partial(image_bounds)
+ All,
+ /// Some specific amount is dirty
+ Partial(Box2D<T, U>)
+}
+
+impl<T, U> DirtyRect<T, U>
+where
+ T: Copy + Clone
+ + PartialOrd + PartialEq
+ + Add<T, Output = T>
+ + Sub<T, Output = T>
+ + Zero
+{
+ /// Creates an empty DirtyRect (indicating nothing is invalid)
+ pub fn empty() -> Self {
+ DirtyRect::Partial(Box2D::zero())
+ }
+
+ /// Returns whether the dirty rect is empty
+ pub fn is_empty(&self) -> bool {
+ match self {
+ DirtyRect::All => false,
+ DirtyRect::Partial(rect) => rect.is_empty(),
+ }
+ }
+
+ /// Replaces self with the empty rect and returns the old value.
+ pub fn replace_with_empty(&mut self) -> Self {
+ ::std::mem::replace(self, DirtyRect::empty())
+ }
+
+ /// Maps over the contents of Partial.
+ pub fn map<F>(self, func: F) -> Self
+ where F: FnOnce(Box2D<T, U>) -> Box2D<T, U>,
+ {
+ use crate::DirtyRect::*;
+
+ match self {
+ All => All,
+ Partial(rect) => Partial(func(rect)),
+ }
+ }
+
+ /// Unions the dirty rects.
+ pub fn union(&self, other: &Self) -> Self {
+ use crate::DirtyRect::*;
+
+ match (*self, *other) {
+ (All, _) | (_, All) => All,
+ (Partial(rect1), Partial(rect2)) => Partial(rect1.union(&rect2)),
+ }
+ }
+
+ /// Intersects the dirty rects.
+ pub fn intersection(&self, other: &Self) -> Self {
+ use crate::DirtyRect::*;
+
+ match (*self, *other) {
+ (All, rect) | (rect, All) => rect,
+ (Partial(rect1), Partial(rect2)) => {
+ Partial(rect1.intersection(&rect2).unwrap_or_else(Box2D::zero))
+ }
+ }
+ }
+
+ /// Converts the dirty rect into a subrect of the given one via intersection.
+ pub fn to_subrect_of(&self, rect: &Box2D<T, U>) -> Box2D<T, U> {
+ use crate::DirtyRect::*;
+
+ match *self {
+ All => *rect,
+ Partial(dirty_rect) => {
+ dirty_rect.intersection(rect).unwrap_or_else(Box2D::zero)
+ }
+ }
+ }
+}
+
+impl<T: Copy, U> Copy for DirtyRect<T, U> {}
+impl<T: Copy, U> Clone for DirtyRect<T, U> {
+ fn clone(&self) -> Self { *self }
+}
+
+impl<T: Copy, U> From<Box2D<T, U>> for DirtyRect<T, U> {
+ fn from(rect: Box2D<T, U>) -> Self {
+ DirtyRect::Partial(rect)
+ }
+}
+
+/// Backing store for blob image command streams.
+pub type BlobImageData = Vec<u8>;
+
+/// Result type for blob raserization.
+pub type BlobImageResult = Result<RasterizedBlobImage, BlobImageError>;
+
+/// Metadata (but not storage) for a blob image.
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct BlobImageDescriptor {
+ /// Surface of the image or tile to render in the same coordinate space as
+ /// the drawing commands.
+ pub rect: LayoutIntRect,
+ /// Format for the data in the backing store.
+ pub format: ImageFormat,
+}
+
+/// Representation of a rasterized blob image. This is obtained by passing
+/// `BlobImageData` to the embedding via the rasterization callback.
+pub struct RasterizedBlobImage {
+ /// The rectangle that was rasterized in device pixels, relative to the
+ /// image or tile.
+ pub rasterized_rect: DeviceIntRect,
+ /// Backing store. The format is stored out of band in `BlobImageDescriptor`.
+ pub data: Arc<Vec<u8>>,
+}
+
+/// Error code for when blob rasterization failed.
+#[derive(Clone, Debug)]
+pub enum BlobImageError {
+ /// Out of memory.
+ Oom,
+ /// Other failure, embedding-specified.
+ Other(String),
+}
+
+
+
+/// A key identifying blob image rasterization work requested from the blob
+/// image rasterizer.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct BlobImageRequest {
+ /// Unique handle to the image.
+ pub key: BlobImageKey,
+ /// Tiling offset in number of tiles.
+ pub tile: TileOffset,
+}
diff --git a/gfx/wr/webrender_api/src/lib.rs b/gfx/wr/webrender_api/src/lib.rs
new file mode 100644
index 0000000000..fb8aba5e58
--- /dev/null
+++ b/gfx/wr/webrender_api/src/lib.rs
@@ -0,0 +1,809 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+//! The `webrender_api` crate contains an assortment types and functions used
+//! by WebRender consumers as well as, in many cases, WebRender itself.
+//!
+//! This separation allows Servo to parallelize compilation across `webrender`
+//! and other crates that depend on `webrender_api`. So in practice, we put
+//! things in this crate when Servo needs to use them. Firefox depends on the
+//! `webrender` crate directly, and so this distinction is not really relevant
+//! there.
+
+#![cfg_attr(feature = "nightly", feature(nonzero))]
+#![cfg_attr(feature = "cargo-clippy", allow(clippy::float_cmp, clippy::too_many_arguments))]
+#![cfg_attr(feature = "cargo-clippy", allow(clippy::unreadable_literal, clippy::new_without_default))]
+
+pub extern crate crossbeam_channel;
+pub extern crate euclid;
+
+extern crate app_units;
+#[macro_use]
+extern crate bitflags;
+extern crate byteorder;
+#[cfg(feature = "nightly")]
+extern crate core;
+#[macro_use]
+extern crate malloc_size_of_derive;
+extern crate serde;
+#[macro_use]
+extern crate serde_derive;
+extern crate time;
+
+extern crate malloc_size_of;
+extern crate peek_poke;
+
+pub mod channel;
+mod color;
+mod display_item;
+mod display_item_cache;
+mod display_list;
+mod font;
+mod gradient_builder;
+mod image;
+pub mod units;
+
+pub use crate::color::*;
+pub use crate::display_item::*;
+pub use crate::display_item_cache::DisplayItemCache;
+pub use crate::display_list::*;
+pub use crate::font::*;
+pub use crate::gradient_builder::*;
+pub use crate::image::*;
+
+use crate::units::*;
+use crate::channel::Receiver;
+use std::marker::PhantomData;
+use std::sync::Arc;
+use std::os::raw::c_void;
+use peek_poke::PeekPoke;
+
+/// Defined here for cbindgen
+pub const MAX_RENDER_TASK_SIZE: i32 = 16384;
+
+/// Width and height in device pixels of image tiles.
+pub type TileSize = u16;
+
+/// Various settings that the caller can select based on desired tradeoffs
+/// between rendering quality and performance / power usage.
+#[derive(Copy, Clone, Deserialize, Serialize)]
+pub struct QualitySettings {
+ /// If true, disable creating separate picture cache slices when the
+ /// scroll root changes. This gives maximum opportunity to find an
+ /// opaque background, which enables subpixel AA. However, it is
+ /// usually significantly more expensive to render when scrolling.
+ pub force_subpixel_aa_where_possible: bool,
+}
+
+impl Default for QualitySettings {
+ fn default() -> Self {
+ QualitySettings {
+ // Prefer performance over maximum subpixel AA quality, since WR
+ // already enables subpixel AA in more situations than other browsers.
+ force_subpixel_aa_where_possible: false,
+ }
+ }
+}
+
+/// An epoch identifies the state of a pipeline in time.
+///
+/// This is mostly used as a synchronization mechanism to observe how/when particular pipeline
+/// updates propagate through WebRender and are applied at various stages.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+pub struct Epoch(pub u32);
+
+impl Epoch {
+ /// Magic invalid epoch value.
+ pub fn invalid() -> Epoch {
+ Epoch(u32::MAX)
+ }
+}
+
+/// ID namespaces uniquely identify different users of WebRender's API.
+///
+/// For example in Gecko each content process uses a separate id namespace.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Eq, MallocSizeOf, PartialEq, Hash, Ord, PartialOrd, PeekPoke)]
+#[derive(Deserialize, Serialize)]
+pub struct IdNamespace(pub u32);
+
+/// A key uniquely identifying a WebRender document.
+///
+/// Instances can manage one or several documents (using the same render backend thread).
+/// Each document will internally correspond to a single scene, and scenes are made of
+/// one or several pipelines.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct DocumentId {
+ ///
+ pub namespace_id: IdNamespace,
+ ///
+ pub id: u32,
+}
+
+impl DocumentId {
+ ///
+ pub fn new(namespace_id: IdNamespace, id: u32) -> Self {
+ DocumentId {
+ namespace_id,
+ id,
+ }
+ }
+
+ ///
+ pub const INVALID: DocumentId = DocumentId { namespace_id: IdNamespace(0), id: 0 };
+}
+
+/// This type carries no valuable semantics for WR. However, it reflects the fact that
+/// clients (Servo) may generate pipelines by different semi-independent sources.
+/// These pipelines still belong to the same `IdNamespace` and the same `DocumentId`.
+/// Having this extra Id field enables them to generate `PipelineId` without collision.
+pub type PipelineSourceId = u32;
+
+/// From the point of view of WR, `PipelineId` is completely opaque and generic as long as
+/// it's clonable, serializable, comparable, and hashable.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct PipelineId(pub PipelineSourceId, pub u32);
+
+impl Default for PipelineId {
+ fn default() -> Self {
+ PipelineId::dummy()
+ }
+}
+
+impl PipelineId {
+ ///
+ pub fn dummy() -> Self {
+ PipelineId(!0, !0)
+ }
+
+ pub const INVALID: Self = PipelineId(!0, !0);
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct FramePublishId(pub u64);
+
+impl FramePublishId {
+ /// Returns a FramePublishId corresponding to the first frame.
+ ///
+ /// Note that we use 0 as the internal id here because the current code
+ /// increments the frame publish id just before ResultMsg::PublishDocument,
+ /// and we want the first id to be 1.
+ pub fn first() -> Self {
+ FramePublishId(0)
+ }
+
+ /// Advances this FramePublishId to the next.
+ pub fn advance(&mut self) {
+ self.0 += 1;
+ }
+
+ /// An invalid sentinel FramePublishId, which will always compare less than
+ /// any valid FrameId.
+ pub const INVALID: Self = FramePublishId(0);
+}
+
+impl Default for FramePublishId {
+ fn default() -> Self {
+ FramePublishId::INVALID
+ }
+}
+
+/// An opaque pointer-sized value.
+#[repr(C)]
+#[derive(Clone)]
+pub struct ExternalEvent {
+ raw: usize,
+}
+
+unsafe impl Send for ExternalEvent {}
+
+impl ExternalEvent {
+ /// Creates the event from an opaque pointer-sized value.
+ pub fn from_raw(raw: usize) -> Self {
+ ExternalEvent { raw }
+ }
+ /// Consumes self to make it obvious that the event should be forwarded only once.
+ pub fn unwrap(self) -> usize {
+ self.raw
+ }
+}
+
+pub type APZScrollGeneration = u64;
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, Default)]
+pub struct SampledScrollOffset {
+ pub offset: LayoutVector2D,
+ pub generation: APZScrollGeneration,
+}
+
+/// A flag in each scrollable frame to represent whether the owner of the frame document
+/// has any scroll-linked effect.
+/// See https://firefox-source-docs.mozilla.org/performance/scroll-linked_effects.html
+/// for a definition of scroll-linked effect.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize, PeekPoke)]
+pub enum HasScrollLinkedEffect {
+ Yes,
+ No,
+}
+
+impl Default for HasScrollLinkedEffect {
+ fn default() -> Self {
+ HasScrollLinkedEffect::No
+ }
+}
+
+#[repr(C)]
+pub struct MinimapData {
+ pub is_root_content: bool,
+ // All rects in local coords relative to the scrolled content's origin.
+ pub visual_viewport: LayoutRect,
+ pub layout_viewport: LayoutRect,
+ pub scrollable_rect: LayoutRect,
+ pub displayport: LayoutRect,
+ // Populated for root content nodes only, otherwise the identity
+ pub zoom_transform: LayoutTransform,
+ // Populated for nodes in the subtree of a root content node
+ // (outside such subtrees we'll have `root_content_scroll_id == 0`).
+ // Stores the enclosing root content node's ExternalScrollId.
+ pub root_content_pipeline_id: PipelineId,
+ pub root_content_scroll_id: u64
+}
+
+/// A handler to integrate WebRender with the thread that contains the `Renderer`.
+pub trait RenderNotifier: Send {
+ ///
+ fn clone(&self) -> Box<dyn RenderNotifier>;
+ /// Wake the thread containing the `Renderer` up (after updates have been put
+ /// in the renderer's queue).
+ fn wake_up(
+ &self,
+ composite_needed: bool,
+ );
+ /// Notify the thread containing the `Renderer` that a new frame is ready.
+ fn new_frame_ready(&self, _: DocumentId, scrolled: bool, composite_needed: bool, frame_publish_id: FramePublishId);
+ /// A Gecko-specific notification mechanism to get some code executed on the
+ /// `Renderer`'s thread, mostly replaced by `NotificationHandler`. You should
+ /// probably use the latter instead.
+ fn external_event(&self, _evt: ExternalEvent) {
+ unimplemented!()
+ }
+ /// Notify the thread containing the `Renderer` that the render backend has been
+ /// shut down.
+ fn shut_down(&self) {}
+}
+
+/// A stage of the rendering pipeline.
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Checkpoint {
+ ///
+ SceneBuilt,
+ ///
+ FrameBuilt,
+ ///
+ FrameTexturesUpdated,
+ ///
+ FrameRendered,
+ /// NotificationRequests get notified with this if they get dropped without having been
+ /// notified. This provides the guarantee that if a request is created it will get notified.
+ TransactionDropped,
+}
+
+/// A handler to notify when a transaction reaches certain stages of the rendering
+/// pipeline.
+pub trait NotificationHandler : Send + Sync {
+ /// Entry point of the handler to implement. Invoked by WebRender.
+ fn notify(&self, when: Checkpoint);
+}
+
+/// A request to notify a handler when the transaction reaches certain stages of the
+/// rendering pipeline.
+///
+/// The request is guaranteed to be notified once and only once, even if the transaction
+/// is dropped before the requested check-point.
+pub struct NotificationRequest {
+ handler: Option<Box<dyn NotificationHandler>>,
+ when: Checkpoint,
+}
+
+impl NotificationRequest {
+ /// Constructor.
+ pub fn new(when: Checkpoint, handler: Box<dyn NotificationHandler>) -> Self {
+ NotificationRequest {
+ handler: Some(handler),
+ when,
+ }
+ }
+
+ /// The specified stage at which point the handler should be notified.
+ pub fn when(&self) -> Checkpoint { self.when }
+
+ /// Called by WebRender at specified stages to notify the registered handler.
+ pub fn notify(mut self) {
+ if let Some(handler) = self.handler.take() {
+ handler.notify(self.when);
+ }
+ }
+}
+
+/// An object that can perform hit-testing without doing synchronous queries to
+/// the RenderBackendThread.
+pub trait ApiHitTester: Send + Sync {
+ /// Does a hit test on display items in the specified document, at the given
+ /// point. The vector of hit results will contain all display items that match,
+ /// ordered from front to back.
+ fn hit_test(&self, point: WorldPoint) -> HitTestResult;
+}
+
+/// A hit tester requested to the render backend thread but not necessarily ready yet.
+///
+/// The request should be resolved as late as possible to reduce the likelihood of blocking.
+pub struct HitTesterRequest {
+ #[doc(hidden)]
+ pub rx: Receiver<Arc<dyn ApiHitTester>>,
+}
+
+impl HitTesterRequest {
+ /// Block until the hit tester is available and return it, consuming teh request.
+ pub fn resolve(self) -> Arc<dyn ApiHitTester> {
+ self.rx.recv().unwrap()
+ }
+}
+
+/// Describe an item that matched a hit-test query.
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct HitTestResultItem {
+ /// The pipeline that the display item that was hit belongs to.
+ pub pipeline: PipelineId,
+
+ /// The tag of the hit display item.
+ pub tag: ItemTag,
+
+ /// The animation id from the stacking context.
+ pub animation_id: u64,
+}
+
+/// Returned by `RenderApi::hit_test`.
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct HitTestResult {
+ /// List of items that are match the hit-test query.
+ pub items: Vec<HitTestResultItem>,
+}
+
+impl Drop for NotificationRequest {
+ fn drop(&mut self) {
+ if let Some(ref mut handler) = self.handler {
+ handler.notify(Checkpoint::TransactionDropped);
+ }
+ }
+}
+
+// This Clone impl yields an "empty" request because we don't want the requests
+// to be notified twice so the request is owned by only one of the API messages
+// (the original one) after the clone.
+// This works in practice because the notifications requests are used for
+// synchronization so we don't need to include them in the recording mechanism
+// in wrench that clones the messages.
+impl Clone for NotificationRequest {
+ fn clone(&self) -> Self {
+ NotificationRequest {
+ when: self.when,
+ handler: None,
+ }
+ }
+}
+
+
+/// A key to identify an animated property binding.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, Eq, Hash, PeekPoke)]
+pub struct PropertyBindingId {
+ pub namespace: IdNamespace,
+ pub uid: u32,
+}
+
+impl PropertyBindingId {
+ /// Constructor.
+ pub fn new(value: u64) -> Self {
+ PropertyBindingId {
+ namespace: IdNamespace((value >> 32) as u32),
+ uid: value as u32,
+ }
+ }
+
+ /// Decompose the ID back into the raw integer.
+ pub fn to_u64(&self) -> u64 {
+ ((self.namespace.0 as u64) << 32) | self.uid as u64
+ }
+}
+
+/// A unique key that is used for connecting animated property
+/// values to bindings in the display list.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub struct PropertyBindingKey<T> {
+ ///
+ pub id: PropertyBindingId,
+ #[doc(hidden)]
+ pub _phantom: PhantomData<T>,
+}
+
+/// Construct a property value from a given key and value.
+impl<T: Copy> PropertyBindingKey<T> {
+ ///
+ pub fn with(self, value: T) -> PropertyValue<T> {
+ PropertyValue { key: self, value }
+ }
+}
+
+impl<T> Into<u64> for PropertyBindingKey<T> {
+ fn into(self) -> u64 {
+ self.id.to_u64()
+ }
+}
+
+impl<T> PropertyBindingKey<T> {
+ /// Constructor.
+ pub fn new(value: u64) -> Self {
+ PropertyBindingKey {
+ id: PropertyBindingId::new(value),
+ _phantom: PhantomData,
+ }
+ }
+}
+
+/// A binding property can either be a specific value
+/// (the normal, non-animated case) or point to a binding location
+/// to fetch the current value from.
+/// Note that Binding has also a non-animated value, the value is
+/// used for the case where the animation is still in-delay phase
+/// (i.e. the animation doesn't produce any animation values).
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
+pub enum PropertyBinding<T> {
+ /// Non-animated value.
+ Value(T),
+ /// Animated binding.
+ Binding(PropertyBindingKey<T>, T),
+}
+
+impl<T: Default> Default for PropertyBinding<T> {
+ fn default() -> Self {
+ PropertyBinding::Value(Default::default())
+ }
+}
+
+impl<T> From<T> for PropertyBinding<T> {
+ fn from(value: T) -> PropertyBinding<T> {
+ PropertyBinding::Value(value)
+ }
+}
+
+impl From<PropertyBindingKey<ColorF>> for PropertyBindingKey<ColorU> {
+ fn from(key: PropertyBindingKey<ColorF>) -> PropertyBindingKey<ColorU> {
+ PropertyBindingKey {
+ id: key.id.clone(),
+ _phantom: PhantomData,
+ }
+ }
+}
+
+impl From<PropertyBindingKey<ColorU>> for PropertyBindingKey<ColorF> {
+ fn from(key: PropertyBindingKey<ColorU>) -> PropertyBindingKey<ColorF> {
+ PropertyBindingKey {
+ id: key.id.clone(),
+ _phantom: PhantomData,
+ }
+ }
+}
+
+impl From<PropertyBinding<ColorF>> for PropertyBinding<ColorU> {
+ fn from(value: PropertyBinding<ColorF>) -> PropertyBinding<ColorU> {
+ match value {
+ PropertyBinding::Value(value) => PropertyBinding::Value(value.into()),
+ PropertyBinding::Binding(k, v) => {
+ PropertyBinding::Binding(k.into(), v.into())
+ }
+ }
+ }
+}
+
+impl From<PropertyBinding<ColorU>> for PropertyBinding<ColorF> {
+ fn from(value: PropertyBinding<ColorU>) -> PropertyBinding<ColorF> {
+ match value {
+ PropertyBinding::Value(value) => PropertyBinding::Value(value.into()),
+ PropertyBinding::Binding(k, v) => {
+ PropertyBinding::Binding(k.into(), v.into())
+ }
+ }
+ }
+}
+
+/// The current value of an animated property. This is
+/// supplied by the calling code.
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq)]
+pub struct PropertyValue<T> {
+ ///
+ pub key: PropertyBindingKey<T>,
+ ///
+ pub value: T,
+}
+
+/// When using `generate_frame()`, a list of `PropertyValue` structures
+/// can optionally be supplied to provide the current value of any
+/// animated properties.
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Default)]
+pub struct DynamicProperties {
+ /// transform list
+ pub transforms: Vec<PropertyValue<LayoutTransform>>,
+ /// opacity
+ pub floats: Vec<PropertyValue<f32>>,
+ /// background color
+ pub colors: Vec<PropertyValue<ColorF>>,
+}
+
+impl DynamicProperties {
+ /// Extend the properties.
+ pub fn extend(&mut self, other: Self) {
+ self.transforms.extend(other.transforms);
+ self.floats.extend(other.floats);
+ self.colors.extend(other.colors);
+ }
+}
+
+/// A C function that takes a pointer to a heap allocation and returns its size.
+///
+/// This is borrowed from the malloc_size_of crate, upon which we want to avoid
+/// a dependency from WebRender.
+pub type VoidPtrToSizeFn = unsafe extern "C" fn(ptr: *const c_void) -> usize;
+
+/// A configuration option that can be changed at runtime.
+///
+/// # Adding a new configuration option
+///
+/// - Add a new enum variant here.
+/// - Add the entry in WR_BOOL_PARAMETER_LIST in gfxPlatform.cpp.
+/// - React to the parameter change anywhere in WebRender where a SetParam message is received.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Parameter {
+ Bool(BoolParameter, bool),
+ Int(IntParameter, i32),
+}
+
+/// Boolean configuration option.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[repr(u32)]
+pub enum BoolParameter {
+ PboUploads = 0,
+ Multithreading = 1,
+ BatchedUploads = 2,
+ DrawCallsForTextureCopy = 3,
+}
+
+/// Integer configuration option.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[repr(u32)]
+pub enum IntParameter {
+ BatchedUploadThreshold = 0,
+}
+
+/// Flags to track why we are rendering.
+#[repr(C)]
+#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Default, Deserialize, MallocSizeOf, Serialize)]
+pub struct RenderReasons(u32);
+
+bitflags! {
+ impl RenderReasons: u32 {
+ /// Equivalent of empty() for the C++ side.
+ const NONE = 0;
+ const SCENE = 1 << 0;
+ const ANIMATED_PROPERTY = 1 << 1;
+ const RESOURCE_UPDATE = 1 << 2;
+ const ASYNC_IMAGE = 1 << 3;
+ const CLEAR_RESOURCES = 1 << 4;
+ const APZ = 1 << 5;
+ /// Window resize
+ const RESIZE = 1 << 6;
+ /// Various widget-related reasons
+ const WIDGET = 1 << 7;
+ /// See Frame::must_be_drawn
+ const TEXTURE_CACHE_FLUSH = 1 << 8;
+ const SNAPSHOT = 1 << 9;
+ const POST_RESOURCE_UPDATES_HOOK = 1 << 10;
+ const CONFIG_CHANGE = 1 << 11;
+ const CONTENT_SYNC = 1 << 12;
+ const FLUSH = 1 << 13;
+ const TESTING = 1 << 14;
+ const OTHER = 1 << 15;
+ /// Vsync isn't actually "why" we render but it can be useful
+ /// to see which frames were driven by the vsync scheduler so
+ /// we store a bit for it.
+ const VSYNC = 1 << 16;
+ const SKIPPED_COMPOSITE = 1 << 17;
+ /// Gecko does some special things when it starts observing vsync
+ /// so it can be useful to know what frames are associated with it.
+ const START_OBSERVING_VSYNC = 1 << 18;
+ const ASYNC_IMAGE_COMPOSITE_UNTIL = 1 << 19;
+ }
+}
+
+impl core::fmt::Debug for RenderReasons {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.is_empty() {
+ write!(f, "{:#x}", Self::empty().bits())
+ } else {
+ bitflags::parser::to_writer(self, f)
+ }
+ }
+}
+
+impl RenderReasons {
+ pub const NUM_BITS: u32 = 17;
+}
+
+/// Flags to enable/disable various builtin debugging tools.
+#[repr(C)]
+#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash, Default, Deserialize, MallocSizeOf, Serialize)]
+pub struct DebugFlags(u32);
+
+bitflags! {
+ impl DebugFlags: u32 {
+ /// Display the frame profiler on screen.
+ const PROFILER_DBG = 1 << 0;
+ /// Display intermediate render targets on screen.
+ const RENDER_TARGET_DBG = 1 << 1;
+ /// Display all texture cache pages on screen.
+ const TEXTURE_CACHE_DBG = 1 << 2;
+ /// Display GPU timing results.
+ const GPU_TIME_QUERIES = 1 << 3;
+ /// Query the number of pixels that pass the depth test divided and show it
+ /// in the profiler as a percentage of the number of pixels in the screen
+ /// (window width times height).
+ const GPU_SAMPLE_QUERIES = 1 << 4;
+ /// Render each quad with their own draw call.
+ ///
+ /// Terrible for performance but can help with understanding the drawing
+ /// order when inspecting renderdoc or apitrace recordings.
+ const DISABLE_BATCHING = 1 << 5;
+ /// Display the pipeline epochs.
+ const EPOCHS = 1 << 6;
+ /// Print driver messages to stdout.
+ const ECHO_DRIVER_MESSAGES = 1 << 7;
+ /// Show an overlay displaying overdraw amount.
+ const SHOW_OVERDRAW = 1 << 8;
+ /// Display the contents of GPU cache.
+ const GPU_CACHE_DBG = 1 << 9;
+ /// Clear evicted parts of the texture cache for debugging purposes.
+ const TEXTURE_CACHE_DBG_CLEAR_EVICTED = 1 << 10;
+ /// Show picture caching debug overlay
+ const PICTURE_CACHING_DBG = 1 << 11;
+ /// Highlight all primitives with colors based on kind.
+ const PRIMITIVE_DBG = 1 << 12;
+ /// Draw a zoom widget showing part of the framebuffer zoomed in.
+ const ZOOM_DBG = 1 << 13;
+ /// Scale the debug renderer down for a smaller screen. This will disrupt
+ /// any mapping between debug display items and page content, so shouldn't
+ /// be used with overlays like the picture caching or primitive display.
+ const SMALL_SCREEN = 1 << 14;
+ /// Disable various bits of the WebRender pipeline, to help narrow
+ /// down where slowness might be coming from.
+ const DISABLE_OPAQUE_PASS = 1 << 15;
+ ///
+ const DISABLE_ALPHA_PASS = 1 << 16;
+ ///
+ const DISABLE_CLIP_MASKS = 1 << 17;
+ ///
+ const DISABLE_TEXT_PRIMS = 1 << 18;
+ ///
+ const DISABLE_GRADIENT_PRIMS = 1 << 19;
+ ///
+ const OBSCURE_IMAGES = 1 << 20;
+ /// Taint the transparent area of the glyphs with a random opacity to easily
+ /// see when glyphs are re-rasterized.
+ const GLYPH_FLASHING = 1 << 21;
+ /// The profiler only displays information that is out of the ordinary.
+ const SMART_PROFILER = 1 << 22;
+ /// If set, dump picture cache invalidation debug to console.
+ const INVALIDATION_DBG = 1 << 23;
+ /// Collect and dump profiler statistics to captures.
+ const PROFILER_CAPTURE = (1 as u32) << 25; // need "as u32" until we have cbindgen#556
+ /// Invalidate picture tiles every frames (useful when inspecting GPU work in external tools).
+ const FORCE_PICTURE_INVALIDATION = (1 as u32) << 26;
+ /// Display window visibility on screen.
+ const WINDOW_VISIBILITY_DBG = 1 << 27;
+ /// Render large blobs with at a smaller size (incorrectly). This is a temporary workaround for
+ /// fuzzing.
+ const RESTRICT_BLOB_SIZE = 1 << 28;
+ }
+}
+
+impl core::fmt::Debug for DebugFlags {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.is_empty() {
+ write!(f, "{:#x}", Self::empty().bits())
+ } else {
+ bitflags::parser::to_writer(self, f)
+ }
+ }
+}
+
+/// Information specific to a primitive type that
+/// uniquely identifies a primitive template by key.
+#[derive(Debug, Clone, Eq, MallocSizeOf, PartialEq, Hash, Serialize, Deserialize)]
+pub enum PrimitiveKeyKind {
+ /// Clear an existing rect, used for special effects on some platforms.
+ Clear,
+ ///
+ Rectangle {
+ ///
+ color: PropertyBinding<ColorU>,
+ },
+}
+
+///
+#[derive(Clone, Copy, Debug)]
+pub enum ScrollLocation {
+ /// Scroll by a certain amount.
+ Delta(LayoutVector2D),
+ /// Scroll to very top of element.
+ Start,
+ /// Scroll to very bottom of element.
+ End,
+}
+
+/// Crash annotations included in crash reports.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub enum CrashAnnotation {
+ CompileShader = 0,
+ DrawShader = 1,
+}
+
+/// Handler to expose support for annotating crash reports.
+pub trait CrashAnnotator : Send {
+ fn set(&self, annotation: CrashAnnotation, value: &std::ffi::CStr);
+ fn clear(&self, annotation: CrashAnnotation);
+ fn box_clone(&self) -> Box<dyn CrashAnnotator>;
+}
+
+impl Clone for Box<dyn CrashAnnotator> {
+ fn clone(&self) -> Box<dyn CrashAnnotator> {
+ self.box_clone()
+ }
+}
+
+/// Guard to add a crash annotation at creation, and clear it at destruction.
+pub struct CrashAnnotatorGuard<'a> {
+ annotator: &'a Option<Box<dyn CrashAnnotator>>,
+ annotation: CrashAnnotation,
+}
+
+impl<'a> CrashAnnotatorGuard<'a> {
+ pub fn new(
+ annotator: &'a Option<Box<dyn CrashAnnotator>>,
+ annotation: CrashAnnotation,
+ value: &std::ffi::CStr,
+ ) -> Self {
+ if let Some(ref annotator) = annotator {
+ annotator.set(annotation, value);
+ }
+ Self {
+ annotator,
+ annotation,
+ }
+ }
+}
+
+impl<'a> Drop for CrashAnnotatorGuard<'a> {
+ fn drop(&mut self) {
+ if let Some(ref annotator) = self.annotator {
+ annotator.clear(self.annotation);
+ }
+ }
+}
diff --git a/gfx/wr/webrender_api/src/units.rs b/gfx/wr/webrender_api/src/units.rs
new file mode 100644
index 0000000000..2d4cc34aab
--- /dev/null
+++ b/gfx/wr/webrender_api/src/units.rs
@@ -0,0 +1,346 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+//! A collection of coordinate spaces and their corresponding Point, Size and Rect types.
+//!
+//! Physical pixels take into account the device pixel ratio and their dimensions tend
+//! to correspond to the allocated size of resources in memory, while logical pixels
+//! don't have the device pixel ratio applied which means they are agnostic to the usage
+//! of hidpi screens and the like.
+//!
+//! The terms "layer" and "stacking context" can be used interchangeably
+//! in the context of coordinate systems.
+
+pub use app_units::Au;
+use euclid::{Length, Rect, Scale, Size2D, Transform3D, Translation2D};
+use euclid::{Point2D, Point3D, Vector2D, Vector3D, SideOffsets2D, Box2D};
+use euclid::HomogeneousVector;
+use peek_poke::PeekPoke;
+// local imports
+use crate::image::DirtyRect;
+
+/// Geometry in the coordinate system of the render target (screen or intermediate
+/// surface) in physical pixels.
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+pub struct DevicePixel;
+
+pub type DeviceIntRect = Box2D<i32, DevicePixel>;
+pub type DeviceIntPoint = Point2D<i32, DevicePixel>;
+pub type DeviceIntSize = Size2D<i32, DevicePixel>;
+pub type DeviceIntLength = Length<i32, DevicePixel>;
+pub type DeviceIntSideOffsets = SideOffsets2D<i32, DevicePixel>;
+pub type DeviceIntVector2D = Vector2D<i32, DevicePixel>;
+
+pub type DeviceRect = Box2D<f32, DevicePixel>;
+pub type DeviceBox2D = Box2D<f32, DevicePixel>;
+pub type DevicePoint = Point2D<f32, DevicePixel>;
+pub type DeviceVector2D = Vector2D<f32, DevicePixel>;
+pub type DeviceSize = Size2D<f32, DevicePixel>;
+pub type DeviceHomogeneousVector = HomogeneousVector<f32, DevicePixel>;
+
+/// Geometry in the coordinate system of the framebuffer in physical pixels.
+/// It's Y-flipped comparing to DevicePixel.
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+pub struct FramebufferPixel;
+
+pub type FramebufferIntPoint = Point2D<i32, FramebufferPixel>;
+pub type FramebufferIntSize = Size2D<i32, FramebufferPixel>;
+pub type FramebufferIntRect = Box2D<i32, FramebufferPixel>;
+
+/// Geometry in the coordinate system of a Picture (intermediate
+/// surface) in physical pixels.
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct PicturePixel;
+
+pub type PictureIntRect = Box2D<i32, PicturePixel>;
+pub type PictureIntPoint = Point2D<i32, PicturePixel>;
+pub type PictureIntSize = Size2D<i32, PicturePixel>;
+pub type PictureRect = Box2D<f32, PicturePixel>;
+pub type PicturePoint = Point2D<f32, PicturePixel>;
+pub type PictureSize = Size2D<f32, PicturePixel>;
+pub type PicturePoint3D = Point3D<f32, PicturePixel>;
+pub type PictureVector2D = Vector2D<f32, PicturePixel>;
+pub type PictureVector3D = Vector3D<f32, PicturePixel>;
+pub type PictureBox2D = Box2D<f32, PicturePixel>;
+
+/// Geometry gets rasterized in a given root coordinate space. This
+/// is often the root spatial node (world space), but may be a local
+/// space for a variety of reasons (e.g. perspective).
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct RasterPixel;
+
+pub type RasterIntRect = Box2D<i32, RasterPixel>;
+pub type RasterIntPoint = Point2D<i32, RasterPixel>;
+pub type RasterIntSize = Size2D<i32, RasterPixel>;
+pub type RasterRect = Box2D<f32, RasterPixel>;
+pub type RasterPoint = Point2D<f32, RasterPixel>;
+pub type RasterSize = Size2D<f32, RasterPixel>;
+pub type RasterPoint3D = Point3D<f32, RasterPixel>;
+pub type RasterVector2D = Vector2D<f32, RasterPixel>;
+pub type RasterVector3D = Vector3D<f32, RasterPixel>;
+
+/// Geometry in a stacking context's local coordinate space (logical pixels).
+#[derive(Hash, Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, Ord, PartialOrd, Deserialize, Serialize, PeekPoke)]
+pub struct LayoutPixel;
+
+pub type LayoutRect = Box2D<f32, LayoutPixel>;
+pub type LayoutPoint = Point2D<f32, LayoutPixel>;
+pub type LayoutPoint3D = Point3D<f32, LayoutPixel>;
+pub type LayoutVector2D = Vector2D<f32, LayoutPixel>;
+pub type LayoutVector3D = Vector3D<f32, LayoutPixel>;
+pub type LayoutSize = Size2D<f32, LayoutPixel>;
+pub type LayoutSideOffsets = SideOffsets2D<f32, LayoutPixel>;
+
+pub type LayoutIntRect = Box2D<i32, LayoutPixel>;
+pub type LayoutIntPoint = Point2D<i32, LayoutPixel>;
+pub type LayoutIntSize = Size2D<i32, LayoutPixel>;
+
+/// Geometry in the document's coordinate space (logical pixels).
+#[derive(Hash, Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+pub struct WorldPixel;
+
+pub type WorldRect = Box2D<f32, WorldPixel>;
+pub type WorldIntRect = Box2D<i32, WorldPixel>;
+pub type WorldPoint = Point2D<f32, WorldPixel>;
+pub type WorldSize = Size2D<f32, WorldPixel>;
+pub type WorldPoint3D = Point3D<f32, WorldPixel>;
+pub type WorldVector2D = Vector2D<f32, WorldPixel>;
+pub type WorldVector3D = Vector3D<f32, WorldPixel>;
+
+/// Offset in number of tiles.
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct Tiles;
+pub type TileOffset = Point2D<i32, Tiles>;
+pub type TileRange = Box2D<i32, Tiles>;
+
+/// Scaling ratio from world pixels to device pixels.
+pub type DevicePixelScale = Scale<f32, WorldPixel, DevicePixel>;
+/// Scaling ratio from layout to world. Used for cases where we know the layout
+/// is in world space, or specifically want to treat it this way.
+pub type LayoutToWorldScale = Scale<f32, LayoutPixel, WorldPixel>;
+/// A complete scaling ratio from layout space to device pixel space.
+pub type LayoutToDeviceScale = Scale<f32, LayoutPixel, DevicePixel>;
+
+pub type LayoutTransform = Transform3D<f32, LayoutPixel, LayoutPixel>;
+pub type LayoutToWorldTransform = Transform3D<f32, LayoutPixel, WorldPixel>;
+pub type WorldToLayoutTransform = Transform3D<f32, WorldPixel, LayoutPixel>;
+
+pub type LayoutToPictureTransform = Transform3D<f32, LayoutPixel, PicturePixel>;
+pub type PictureToLayoutTransform = Transform3D<f32, PicturePixel, LayoutPixel>;
+
+pub type LayoutToRasterTransform = Transform3D<f32, LayoutPixel, RasterPixel>;
+pub type RasterToLayoutTransform = Transform3D<f32, RasterPixel, LayoutPixel>;
+
+pub type PictureToRasterTransform = Transform3D<f32, PicturePixel, RasterPixel>;
+pub type RasterToPictureTransform = Transform3D<f32, RasterPixel, PicturePixel>;
+
+/// Scaling ratio from picture pixels to raster pixels (e.g. if scaling a picture surface up/down).
+pub type RasterPixelScale = Scale<f32, PicturePixel, RasterPixel>;
+
+// Fixed position coordinates, to avoid float precision errors.
+pub type LayoutPointAu = Point2D<Au, LayoutPixel>;
+pub type LayoutRectAu = Box2D<Au, LayoutPixel>;
+pub type LayoutSizeAu = Size2D<Au, LayoutPixel>;
+pub type LayoutVector2DAu = Vector2D<Au, LayoutPixel>;
+pub type LayoutSideOffsetsAu = SideOffsets2D<Au, LayoutPixel>;
+
+pub type ImageDirtyRect = DirtyRect<i32, DevicePixel>;
+pub type BlobDirtyRect = DirtyRect<i32, LayoutPixel>;
+
+pub type BlobToDeviceTranslation = Translation2D<i32, LayoutPixel, DevicePixel>;
+
+/// Stores two coordinates in texel space. The coordinates
+/// are stored in texel coordinates because the texture atlas
+/// may grow. Storing them as texel coords and normalizing
+/// the UVs in the vertex shader means nothing needs to be
+/// updated on the CPU when the texture size changes.
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TexelRect {
+ pub uv0: DevicePoint,
+ pub uv1: DevicePoint,
+}
+
+impl TexelRect {
+ pub fn new(u0: f32, v0: f32, u1: f32, v1: f32) -> Self {
+ TexelRect {
+ uv0: DevicePoint::new(u0, v0),
+ uv1: DevicePoint::new(u1, v1),
+ }
+ }
+
+ pub fn invalid() -> Self {
+ TexelRect {
+ uv0: DevicePoint::new(-1.0, -1.0),
+ uv1: DevicePoint::new(-1.0, -1.0),
+ }
+ }
+}
+
+impl Into<TexelRect> for DeviceIntRect {
+ fn into(self) -> TexelRect {
+ TexelRect {
+ uv0: self.min.to_f32(),
+ uv1: self.max.to_f32(),
+ }
+ }
+}
+
+const MAX_AU_FLOAT: f32 = 1.0e6;
+
+pub trait AuHelpers<T> {
+ fn from_au(data: T) -> Self;
+ fn to_au(&self) -> T;
+}
+
+impl AuHelpers<LayoutSizeAu> for LayoutSize {
+ fn from_au(size: LayoutSizeAu) -> Self {
+ LayoutSize::new(
+ size.width.to_f32_px(),
+ size.height.to_f32_px(),
+ )
+ }
+
+ fn to_au(&self) -> LayoutSizeAu {
+ let width = self.width.min(2.0 * MAX_AU_FLOAT);
+ let height = self.height.min(2.0 * MAX_AU_FLOAT);
+
+ LayoutSizeAu::new(
+ Au::from_f32_px(width),
+ Au::from_f32_px(height),
+ )
+ }
+}
+
+impl AuHelpers<LayoutVector2DAu> for LayoutVector2D {
+ fn from_au(size: LayoutVector2DAu) -> Self {
+ LayoutVector2D::new(
+ size.x.to_f32_px(),
+ size.y.to_f32_px(),
+ )
+ }
+
+ fn to_au(&self) -> LayoutVector2DAu {
+ LayoutVector2DAu::new(
+ Au::from_f32_px(self.x),
+ Au::from_f32_px(self.y),
+ )
+ }
+}
+
+impl AuHelpers<LayoutPointAu> for LayoutPoint {
+ fn from_au(point: LayoutPointAu) -> Self {
+ LayoutPoint::new(
+ point.x.to_f32_px(),
+ point.y.to_f32_px(),
+ )
+ }
+
+ fn to_au(&self) -> LayoutPointAu {
+ let x = self.x.min(MAX_AU_FLOAT).max(-MAX_AU_FLOAT);
+ let y = self.y.min(MAX_AU_FLOAT).max(-MAX_AU_FLOAT);
+
+ LayoutPointAu::new(
+ Au::from_f32_px(x),
+ Au::from_f32_px(y),
+ )
+ }
+}
+
+impl AuHelpers<LayoutRectAu> for LayoutRect {
+ fn from_au(rect: LayoutRectAu) -> Self {
+ LayoutRect {
+ min: LayoutPoint::from_au(rect.min),
+ max: LayoutPoint::from_au(rect.max),
+ }
+ }
+
+ fn to_au(&self) -> LayoutRectAu {
+ LayoutRectAu {
+ min: self.min.to_au(),
+ max: self.max.to_au(),
+ }
+ }
+}
+
+impl AuHelpers<LayoutSideOffsetsAu> for LayoutSideOffsets {
+ fn from_au(offsets: LayoutSideOffsetsAu) -> Self {
+ LayoutSideOffsets::new(
+ offsets.top.to_f32_px(),
+ offsets.right.to_f32_px(),
+ offsets.bottom.to_f32_px(),
+ offsets.left.to_f32_px(),
+ )
+ }
+
+ fn to_au(&self) -> LayoutSideOffsetsAu {
+ LayoutSideOffsetsAu::new(
+ Au::from_f32_px(self.top),
+ Au::from_f32_px(self.right),
+ Au::from_f32_px(self.bottom),
+ Au::from_f32_px(self.left),
+ )
+ }
+}
+
+pub trait RectExt {
+ type Point;
+ fn top_left(&self) -> Self::Point;
+ fn top_right(&self) -> Self::Point;
+ fn bottom_left(&self) -> Self::Point;
+ fn bottom_right(&self) -> Self::Point;
+}
+
+impl<U> RectExt for Rect<f32, U> {
+ type Point = Point2D<f32, U>;
+ fn top_left(&self) -> Self::Point {
+ self.min()
+ }
+ fn top_right(&self) -> Self::Point {
+ Point2D::new(self.max_x(), self.min_y())
+ }
+ fn bottom_left(&self) -> Self::Point {
+ Point2D::new(self.min_x(), self.max_y())
+ }
+ fn bottom_right(&self) -> Self::Point {
+ self.max()
+ }
+}
+
+impl<U> RectExt for Box2D<f32, U> {
+ type Point = Point2D<f32, U>;
+ fn top_left(&self) -> Self::Point {
+ self.min
+ }
+ fn top_right(&self) -> Self::Point {
+ Point2D::new(self.max.x, self.min.y)
+ }
+ fn bottom_left(&self) -> Self::Point {
+ Point2D::new(self.min.x, self.max.y)
+ }
+ fn bottom_right(&self) -> Self::Point {
+ self.max
+ }
+}
+
+// A few helpers to convert to cast between coordinate spaces that are often equivalent.
+
+#[inline]
+pub fn layout_rect_as_picture_rect(layout_rect: &LayoutRect) -> PictureRect {
+ layout_rect.cast_unit()
+}
+
+#[inline]
+pub fn layout_vector_as_picture_vector(layout_vector: LayoutVector2D) -> PictureVector2D {
+ layout_vector.cast_unit()
+}
+
+#[inline]
+pub fn device_size_as_framebuffer_size(framebuffer_size: DeviceIntSize) -> FramebufferIntSize {
+ framebuffer_size.cast_unit()
+}
+
+#[inline]
+pub fn device_rect_as_framebuffer_rect(framebuffer_rect: &DeviceIntRect) -> FramebufferIntRect {
+ framebuffer_rect.cast_unit()
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-17 00:12:22 +0000