Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #26335 - jdm:wrup, r=SimonSapin

Browse source 
Update webrender.
This commit is contained in:
bors-servo 2020-05-12 14:56:19 -04:00 • committed by GitHub
commit ea4ae04655
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
28 changed files with 250 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/canvas/Cargo.toml
View file

@ -25,7 +25,7 @@ cssparser = "0.27"
embedder_traits = {path = "../embedder_traits"}
euclid = "0.20"
fnv = "1.0"
gleam = "0.9"
gleam = "0.11"
half = "1"
ipc-channel = "0.14"
log = "0.4"

7
components/canvas/canvas_data.rs
View file

@ -368,6 +368,7 @@ pub struct CanvasData<'a> {
state: CanvasPaintState<'a>,
saved_states: Vec<CanvasPaintState<'a>>,
webrender_api: webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
image_key: Option<webrender_api::ImageKey>,
/// An old webrender image key that can be deleted when the next epoch ends.
old_image_key: Option<webrender_api::ImageKey>,
@ -384,6 +385,7 @@ impl<'a> CanvasData<'a> {
pub fn new(
size: Size2D<u64>,
webrender_api_sender: webrender_api::RenderApiSender,
webrender_doc: webrender_api::DocumentId,
antialias: AntialiasMode,
canvas_id: CanvasId,
) -> CanvasData<'a> {
@ -397,6 +399,7 @@ impl<'a> CanvasData<'a> {
state: CanvasPaintState::new(antialias),
saved_states: vec![],
webrender_api: webrender_api,
webrender_doc,
image_key: None,
old_image_key: None,
very_old_image_key: None,
@ -996,7 +999,7 @@ impl<'a> CanvasData<'a> {
txn.delete_image(image_key);
}
self.webrender_api.update_resources(txn.resource_updates);
self.webrender_api.send_transaction(self.webrender_doc, txn);
let data = CanvasImageData {
image_key: self.image_key.unwrap(),
@ -1116,7 +1119,7 @@ impl<'a> Drop for CanvasData<'a> {
txn.delete_image(image_key);
}
self.webrender_api.update_resources(txn.resource_updates);
self.webrender_api.send_transaction(self.webrender_doc, txn);
}
}

11
components/canvas/canvas_paint_thread.rs
View file

@ -75,11 +75,13 @@ impl<'a> CanvasPaintThread<'a> {
id_sender: creator,
size,
webrender_sender: webrenderer_api_sender,
webrender_doc,
antialias
}) => {
let canvas_id = canvas_paint_thread.create_canvas(
size,
webrenderer_api_sender,
webrender_doc,
antialias,
);
creator.send(canvas_id).unwrap();
@ -103,6 +105,7 @@ impl<'a> CanvasPaintThread<'a> {
&mut self,
size: Size2D<u64>,
webrender_api_sender: webrender_api::RenderApiSender,
webrender_doc: webrender_api::DocumentId,
antialias: bool,
) -> CanvasId {
let antialias = if antialias {
@ -114,7 +117,13 @@ impl<'a> CanvasPaintThread<'a> {
let canvas_id = self.next_canvas_id.clone();
self.next_canvas_id.0 += 1;
let canvas_data = CanvasData::new(size, webrender_api_sender, antialias, canvas_id.clone());
let canvas_data = CanvasData::new(
size,
webrender_api_sender,
webrender_doc,
antialias,
canvas_id.clone(),
);
self.canvases.insert(canvas_id.clone(), canvas_data);
canvas_id

2
components/canvas/webgl_mode/inprocess.rs
View file

@ -40,6 +40,7 @@ impl WebGLComm {
surfman: WebrenderSurfman,
webrender_gl: Rc<dyn gleam::gl::Gl>,
webrender_api_sender: webrender_api::RenderApiSender,
webrender_doc: webrender_api::DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
api_type: GlType,
) -> WebGLComm {
@ -53,6 +54,7 @@ impl WebGLComm {
// This implementation creates a single `WebGLThread` for all the pipelines.
let init = WebGLThreadInit {
webrender_api_sender,
webrender_doc,
external_images,
sender: sender.clone(),
receiver,

14
components/canvas/webgl_thread.rs
View file

@ -221,6 +221,7 @@ pub(crate) struct WebGLThread {
device: Device,
/// Channel used to generate/update or delete `webrender_api::ImageKey`s.
webrender_api: webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
/// Map of live WebGLContexts.
contexts: FnvHashMap<WebGLContextId, GLContextData>,
/// Cached information for WebGLContexts.
@ -257,6 +258,7 @@ pub type SurfaceProvider = Box<dyn surfman_chains::SurfaceProvider<Device> + Sen
pub(crate) struct WebGLThreadInit {
pub webxr_surface_providers: SurfaceProviders,
pub webrender_api_sender: webrender_api::RenderApiSender,
pub webrender_doc: webrender_api::DocumentId,
pub external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
pub sender: WebGLSender<WebGLMsg>,
pub receiver: WebGLReceiver<WebGLMsg>,
@ -276,6 +278,7 @@ impl WebGLThread {
pub(crate) fn new(
WebGLThreadInit {
webrender_api_sender,
webrender_doc,
external_images,
sender,
receiver,
@ -293,6 +296,7 @@ impl WebGLThread {
.create_device(&adapter)
.expect("Couldn't open WebGL device!"),
webrender_api: webrender_api_sender.create_api(),
webrender_doc,
contexts: Default::default(),
cached_context_info: Default::default(),
bound_context_id: None,
@ -652,6 +656,7 @@ impl WebGLThread {
let image_key = Self::create_wr_external_image(
&self.webrender_api,
self.webrender_doc,
size.to_i32(),
has_alpha,
id,
@ -714,6 +719,7 @@ impl WebGLThread {
let texture_target = current_wr_texture_target(&self.device);
Self::update_wr_external_image(
&self.webrender_api,
self.webrender_doc,
size.to_i32(),
has_alpha,
context_id,
@ -732,7 +738,7 @@ impl WebGLThread {
if let Some(info) = self.cached_context_info.remove(&context_id) {
let mut txn = webrender_api::Transaction::new();
txn.delete_image(info.image_key);
self.webrender_api.update_resources(txn.resource_updates)
self.webrender_api.send_transaction(self.webrender_doc, txn)
}
// We need to make the context current so its resources can be disposed of.
@ -1016,6 +1022,7 @@ impl WebGLThread {
/// Creates a `webrender_api::ImageKey` that uses shared textures.
fn create_wr_external_image(
webrender_api: &webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
size: Size2D<i32>,
alpha: bool,
context_id: WebGLContextId,
@ -1027,7 +1034,7 @@ impl WebGLThread {
let image_key = webrender_api.generate_image_key();
let mut txn = webrender_api::Transaction::new();
txn.add_image(image_key, descriptor, data, None);
webrender_api.update_resources(txn.resource_updates);
webrender_api.send_transaction(webrender_doc, txn);
image_key
}
@ -1035,6 +1042,7 @@ impl WebGLThread {
/// Updates a `webrender_api::ImageKey` that uses shared textures.
fn update_wr_external_image(
webrender_api: &webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
size: Size2D<i32>,
alpha: bool,
context_id: WebGLContextId,
@ -1046,7 +1054,7 @@ impl WebGLThread {
let mut txn = webrender_api::Transaction::new();
txn.update_image(image_key, descriptor, data, &webrender_api::DirtyRect::All);
webrender_api.update_resources(txn.resource_updates);
webrender_api.send_transaction(webrender_doc, txn);
}
/// Helper function to create a `webrender_api::ImageDescriptor`.

1
components/canvas_traits/lib.rs
View file

@ -27,6 +27,7 @@ pub enum ConstellationCanvasMsg {
id_sender: Sender<CanvasId>,
size: Size2D<u64>,
webrender_sender: webrender_api::RenderApiSender,
webrender_doc: webrender_api::DocumentId,
antialias: bool,
},
Exit,

2
components/compositing/Cargo.toml
View file

@ -21,7 +21,7 @@ crossbeam-channel = "0.4"
embedder_traits = {path = "../embedder_traits"}
euclid = "0.20"
gfx_traits = {path = "../gfx_traits"}
gleam = {version = "0.9", optional = true}
gleam = {version = "0.11", optional = true}
image = "0.23"
ipc-channel = "0.14"
libc = "0.2"

28
components/constellation/constellation.rs
View file

@ -738,6 +738,7 @@ enum WebrenderMsg {
fn handle_webrender_message(
pending_wr_frame: &AtomicBool,
webrender_api: &webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
msg: WebrenderMsg,
) {
match msg {
@ -810,9 +811,26 @@ fn handle_webrender_message(
let _ = sender.send(webrender_api.generate_image_key());
},
WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateResources(updates)) |
WebrenderMsg::Net(net_traits::WebrenderImageMsg::UpdateResources(updates)) => {
webrender_api.update_resources(updates);
WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateImages(updates)) => {
let mut txn = webrender_api::Transaction::new();
for update in updates {
match update {
script_traits::ImageUpdate::AddImage(key, desc, data) => {
txn.add_image(key, desc, data, None)
},
script_traits::ImageUpdate::DeleteImage(key) => txn.delete_image(key),
script_traits::ImageUpdate::UpdateImage(key, desc, data) => {
txn.update_image(key, desc, data, &webrender_api::DirtyRect::All)
},
}
}
webrender_api.send_transaction(webrender_doc, txn);
},
WebrenderMsg::Net(net_traits::WebrenderImageMsg::AddImage(key, desc, data)) => {
let mut txn = webrender_api::Transaction::new();
txn.add_image(key, desc, data, None);
webrender_api.send_transaction(webrender_doc, txn);
},
}
}
@ -916,6 +934,7 @@ where
ipc::channel().expect("ipc channel failure");
let webrender_api = state.webrender_api_sender.create_api();
let webrender_doc = state.webrender_document;
let pending_wr_frame_clone = state.pending_wr_frame.clone();
ROUTER.add_route(
webrender_ipc_receiver.to_opaque(),
@ -923,6 +942,7 @@ where
handle_webrender_message(
&pending_wr_frame_clone,
&webrender_api,
webrender_doc,
WebrenderMsg::Layout(message.to().expect("conversion failure")),
)
}),
@ -936,6 +956,7 @@ where
handle_webrender_message(
&pending_wr_frame_clone,
&webrender_api,
webrender_doc,
WebrenderMsg::Net(message.to().expect("conversion failure")),
)
}),
@ -4351,6 +4372,7 @@ where
id_sender: canvas_id_sender,
size,
webrender_sender: webrender_api,
webrender_doc: self.webrender_document,
antialias: self.enable_canvas_antialiasing,
}) {
return warn!("Create canvas paint thread failed ({})", e);

6
components/gfx/Cargo.toml
View file

@ -43,9 +43,9 @@ ucd = "0.1.1"
[target.'cfg(target_os = "macos")'.dependencies]
byteorder = "1.0"
core-foundation = "0.6"
core-graphics = "0.17"
core-text = "13.0"
core-foundation = "0.7"
core-graphics = "0.19"
core-text = "15.0"
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
freetype = "0.4"

9
components/gfx/font_cache_thread.rs
View file

@ -137,6 +137,7 @@ struct FontCache {
core_resource_thread: CoreResourceThread,
webrender_api: webrender_api::RenderApi,
webrender_fonts: HashMap<Atom, webrender_api::FontKey>,
webrender_doc: webrender_api::DocumentId,
font_instances: HashMap<(webrender_api::FontKey, Au), webrender_api::FontInstanceKey>,
}
@ -180,6 +181,7 @@ impl FontCache {
},
Command::GetFontInstance(font_key, size, result) => {
let webrender_api = &self.webrender_api;
let doc = self.webrender_doc;
let instance_key =
*self
@ -189,7 +191,7 @@ impl FontCache {
let key = webrender_api.generate_font_instance_key();
let mut txn = webrender_api::Transaction::new();
txn.add_font_instance(key, font_key, size, None, None, Vec::new());
webrender_api.update_resources(txn.resource_updates);
webrender_api.send_transaction(doc, txn);
key
});
@ -389,6 +391,7 @@ impl FontCache {
fn get_font_template_info(&mut self, template: Arc<FontTemplateData>) -> FontTemplateInfo {
let webrender_api = &self.webrender_api;
let doc = self.webrender_doc;
let webrender_fonts = &mut self.webrender_fonts;
let font_key = *webrender_fonts
@ -401,7 +404,7 @@ impl FontCache {
(None, Some(native_font)) => txn.add_native_font(font_key, native_font),
(None, None) => txn.add_raw_font(font_key, template.bytes(), 0),
}
webrender_api.update_resources(txn.resource_updates);
webrender_api.send_transaction(doc, txn);
font_key
});
@ -442,6 +445,7 @@ impl FontCacheThread {
pub fn new(
core_resource_thread: CoreResourceThread,
webrender_api: webrender_api::RenderApi,
webrender_doc: webrender_api::DocumentId,
) -> FontCacheThread {
let (chan, port) = ipc::channel().unwrap();
@ -461,6 +465,7 @@ impl FontCacheThread {
font_context: FontContextHandle::new(),
core_resource_thread,
webrender_api,
webrender_doc,
webrender_fonts: HashMap::new(),
font_instances: HashMap::new(),
};

43
components/layout/display_list/builder.rs
View file

@ -14,7 +14,9 @@ use crate::display_list::background::{self, get_cyclic};
use crate::display_list::border;
use crate::display_list::gradient;
use crate::display_list::items::{self, BaseDisplayItem, ClipScrollNode};
use crate::display_list::items::{ClipScrollNodeIndex, ClipScrollNodeType, ClippingAndScrolling};
use crate::display_list::items::{
ClipScrollNodeIndex, ClipScrollNodeType, ClipType, ClippingAndScrolling,
};
use crate::display_list::items::{ClippingRegion, DisplayItem, DisplayItemMetadata, DisplayList};
use crate::display_list::items::{CommonDisplayItem, DisplayListSection};
use crate::display_list::items::{IframeDisplayItem, OpaqueNode};
@ -70,7 +72,7 @@ use style_traits::ToCss;
use webrender_api::units::{LayoutRect, LayoutTransform, LayoutVector2D};
use webrender_api::{self, BorderDetails, BorderRadius, BorderSide, BoxShadowClipMode, ColorF};
use webrender_api::{ColorU, ExternalScrollId, FilterOp, GlyphInstance, ImageRendering, LineStyle};
use webrender_api::{NinePatchBorder, NinePatchBorderSource, NormalBorder};
use webrender_api::{NinePatchBorder, NinePatchBorderSource, NormalBorder, PropertyBinding};
use webrender_api::{ScrollSensitivity, StickyOffsetBounds};
static THREAD_TINT_COLORS: [ColorF; 8] = [
@ -424,15 +426,8 @@ impl<'a> DisplayListBuildState<'a> {
}
fn add_late_clip_node(&mut self, rect: LayoutRect, radii: BorderRadius) -> ClipScrollNodeIndex {
let mut clip = ClippingRegion::from_rect(rect);
clip.intersect_with_rounded_rect(rect, radii);
let node = ClipScrollNode {
parent_index: self.current_clipping_and_scrolling.scrolling,
clip,
content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
node_type: ClipScrollNodeType::Clip,
};
let node =
ClipScrollNode::rounded(rect, radii, self.current_clipping_and_scrolling.scrolling);
// We want the scroll root to be defined before any possible item that could use it,
// so we make sure that it is added to the beginning of the parent "real" (non-pseudo)
@ -721,8 +716,9 @@ impl Fragment {
state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new(
base,
webrender_api::RectangleDisplayItem {
color: background_color.to_layout(),
color: PropertyBinding::Value(background_color.to_layout()),
common: items::empty_common_item_properties(),
bounds: bounds.to_layout(),
},
)));
});
@ -1468,7 +1464,8 @@ impl Fragment {
base,
webrender_api::RectangleDisplayItem {
common: items::empty_common_item_properties(),
color: background_color.to_layout(),
color: PropertyBinding::Value(background_color.to_layout()),
bounds: stacking_relative_border_box.to_layout(),
},
)));
}
@ -1514,7 +1511,8 @@ impl Fragment {
base,
webrender_api::RectangleDisplayItem {
common: items::empty_common_item_properties(),
color: self.style().get_inherited_text().color.to_layout(),
color: PropertyBinding::Value(self.style().get_inherited_text().color.to_layout()),
bounds: insertion_point_bounds.to_layout(),
},
)));
}
@ -1697,7 +1695,8 @@ impl Fragment {
base,
webrender_api::RectangleDisplayItem {
common: items::empty_common_item_properties(),
color: ColorF::TRANSPARENT,
color: PropertyBinding::Value(ColorF::TRANSPARENT),
bounds: content_size.to_layout(),
},
)));
}
@ -2639,10 +2638,18 @@ impl BlockFlow {
.to_physical(self.fragment.style.writing_mode);
let clip_rect = border_box.inner_rect(border_widths);
let mut clip = ClippingRegion::from_rect(clip_rect.to_layout());
let clip = ClippingRegion::from_rect(clip_rect.to_layout());
let radii = build_border_radius_for_inner_rect(border_box, &self.fragment.style);
if !radii.is_zero() {
clip.intersect_with_rounded_rect(clip_rect.to_layout(), radii)
let node = ClipScrollNode::rounded(
clip_rect.to_layout(),
radii,
state.current_clipping_and_scrolling.scrolling,
);
let clip_id = state.add_clip_scroll_node(node);
let new_clipping_and_scrolling = ClippingAndScrolling::simple(clip_id);
self.base.clipping_and_scrolling = Some(new_clipping_and_scrolling);
state.current_clipping_and_scrolling = new_clipping_and_scrolling;
}
let content_size = self.base.overflow.scroll.origin + self.base.overflow.scroll.size;
@ -2709,7 +2716,7 @@ impl BlockFlow {
parent_index: self.clipping_and_scrolling().scrolling,
clip: ClippingRegion::from_rect(clip_rect.to_layout()),
content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
node_type: ClipScrollNodeType::Clip,
node_type: ClipScrollNodeType::Clip(ClipType::Rect),
});
let new_indices = ClippingAndScrolling::new(new_index, new_index);

105
components/layout/display_list/items.rs
View file

@ -24,7 +24,7 @@ use std::f32;
use std::fmt;
use style::computed_values::_servo_top_layer::T as InTopLayer;
use webrender_api as wr;
use webrender_api::units::{LayoutPixel, LayoutPoint, LayoutRect, LayoutSize, LayoutTransform};
use webrender_api::units::{LayoutPixel, LayoutRect, LayoutTransform};
use webrender_api::{
BorderRadius, ClipId, ClipMode, CommonItemProperties, ComplexClipRegion, ExternalScrollId,
FilterOp, GlyphInstance, GradientStop, ImageKey, MixBlendMode, PrimitiveFlags,
@ -334,12 +334,18 @@ pub struct StickyFrameData {
pub horizontal_offset_bounds: StickyOffsetBounds,
}
#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
pub enum ClipType {
Rounded(ComplexClipRegion),
Rect,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub enum ClipScrollNodeType {
Placeholder,
ScrollFrame(ScrollSensitivity, ExternalScrollId),
StickyFrame(StickyFrameData),
Clip,
Clip(ClipType),
}
/// Defines a clip scroll node.
@ -371,6 +377,24 @@ impl ClipScrollNode {
pub fn is_placeholder(&self) -> bool {
self.node_type == ClipScrollNodeType::Placeholder
}
pub fn rounded(
clip_rect: LayoutRect,
radii: BorderRadius,
parent_index: ClipScrollNodeIndex,
) -> ClipScrollNode {
let complex_region = ComplexClipRegion {
rect: clip_rect,
radii,
mode: ClipMode::Clip,
};
ClipScrollNode {
parent_index,
clip: ClippingRegion::from_rect(clip_rect),
content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
node_type: ClipScrollNodeType::Clip(ClipType::Rounded(complex_region)),
}
}
}
/// One drawing command in the list.
@ -455,7 +479,6 @@ pub fn empty_common_item_properties() -> CommonItemProperties {
spatial_id: SpatialId::root_scroll_node(wr::PipelineId::dummy()),
hit_info: None,
flags: PrimitiveFlags::empty(),
item_key: None,
}
}
@ -466,11 +489,6 @@ pub fn empty_common_item_properties() -> CommonItemProperties {
pub struct ClippingRegion {
/// The main rectangular region. This does not include any corners.
pub main: LayoutRect,
/// Any complex regions.
///
/// TODO(pcwalton): Atomically reference count these? Not sure if it's worth the trouble.
/// Measure and follow up.
pub complex: Vec<ComplexClipRegion>,
}
impl ClippingRegion {
@ -479,7 +497,6 @@ impl ClippingRegion {
pub fn empty() -> ClippingRegion {
ClippingRegion {
main: LayoutRect::zero(),
complex: Vec::new(),
}
}
@ -488,45 +505,13 @@ impl ClippingRegion {
pub fn max() -> ClippingRegion {
ClippingRegion {
main: LayoutRect::max_rect(),
complex: Vec::new(),
}
}
/// Returns a clipping region that represents the given rectangle.
#[inline]
pub fn from_rect(rect: LayoutRect) -> ClippingRegion {
ClippingRegion {
main: rect,
complex: Vec::new(),
}
}
/// Intersects this clipping region with the given rounded rectangle.
#[inline]
pub fn intersect_with_rounded_rect(&mut self, rect: LayoutRect, radii: BorderRadius) {
let new_complex_region = ComplexClipRegion {
rect,
radii,
mode: ClipMode::Clip,
};
// FIXME(pcwalton): This is O(n²) worst case for disjoint clipping regions. Is that OK?
// They're slow anyway…
//
// Possibly relevant if we want to do better:
//
// http://www.inrg.csie.ntu.edu.tw/algorithm2014/presentation/D&C%20Lee-84.pdf
for existing_complex_region in &mut self.complex {
if completely_encloses(&existing_complex_region, &new_complex_region) {
*existing_complex_region = new_complex_region;
return;
}
if completely_encloses(&new_complex_region, &existing_complex_region) {
return;
}
}
self.complex.push(new_complex_region);
ClippingRegion { main: rect }
}
}
@ -536,46 +521,12 @@ impl fmt::Debug for ClippingRegion {
write!(f, "ClippingRegion::Max")
} else if *self == ClippingRegion::empty() {
write!(f, "ClippingRegion::Empty")
} else if self.main == LayoutRect::max_rect() {
write!(f, "ClippingRegion(Complex={:?})", self.complex)
} else {
write!(
f,
"ClippingRegion(Rect={:?}, Complex={:?})",
self.main, self.complex
)
write!(f, "ClippingRegion(Rect={:?})", self.main,)
}
}
}
// TODO(pcwalton): This could be more aggressive by considering points that touch the inside of
// the border radius ellipse.
fn completely_encloses(this: &ComplexClipRegion, other: &ComplexClipRegion) -> bool {
let left = this.radii.top_left.width.max(this.radii.bottom_left.width);
let top = this.radii.top_left.height.max(this.radii.top_right.height);
let right = this
.radii
.top_right
.width
.max(this.radii.bottom_right.width);
let bottom = this
.radii
.bottom_left
.height
.max(this.radii.bottom_right.height);
let interior = LayoutRect::new(
LayoutPoint::new(this.rect.origin.x + left, this.rect.origin.y + top),
LayoutSize::new(
this.rect.size.width - left - right,
this.rect.size.height - top - bottom,
),
);
interior.origin.x <= other.rect.origin.x &&
interior.origin.y <= other.rect.origin.y &&
interior.max_x() >= other.rect.max_x() &&
interior.max_y() >= other.rect.max_y()
}
/// Metadata attached to each display item. This is useful for performing auxiliary threads with
/// the display list involving hit testing: finding the originating DOM node and determining the
/// cursor to use when the element is hovered over.

2
components/layout/display_list/mod.rs
View file

@ -12,7 +12,7 @@ pub use self::conversions::ToLayout;
mod background;
mod border;
mod builder;
mod conversions;
pub(crate) mod conversions;
mod gradient;
pub mod items;
mod webrender_helpers;

26
components/layout/display_list/webrender_helpers.rs
View file

@ -7,7 +7,7 @@
// This might be achieved by sharing types between WR and Servo display lists, or
// completely converting layout to directly generate WebRender display lists, for example.
use crate::display_list::items::{BaseDisplayItem, ClipScrollNode, ClipScrollNodeType};
use crate::display_list::items::{BaseDisplayItem, ClipScrollNode, ClipScrollNodeType, ClipType};
use crate::display_list::items::{DisplayItem, DisplayList, StackingContextType};
use msg::constellation_msg::PipelineId;
use webrender_api::units::LayoutPoint;
@ -269,16 +269,19 @@ impl DisplayItem {
.expect("Tried to use WebRender parent ClipId before it was defined.");
match node.node_type {
ClipScrollNodeType::Clip => {
let id = builder.define_clip(
&SpaceAndClipInfo {
clip_id: parent_clip_id,
spatial_id: parent_spatial_id,
ClipScrollNodeType::Clip(clip_type) => {
let space_and_clip_info = SpaceAndClipInfo {
clip_id: parent_clip_id,
spatial_id: parent_spatial_id,
};
let id = match clip_type {
ClipType::Rect => {
builder.define_clip_rect(&space_and_clip_info, item_rect)
},
item_rect,
node.clip.complex.clone(),
None,
);
ClipType::Rounded(complex) => {
builder.define_clip_rounded_rect(&space_and_clip_info, complex)
},
};
state.spatial_ids[item.node_index.to_index()] = Some(parent_spatial_id);
state.clip_ids[item.node_index.to_index()] = Some(id);
@ -292,8 +295,6 @@ impl DisplayItem {
Some(external_id),
node.content_rect,
node.clip.main,
node.clip.complex.clone(),
None,
scroll_sensitivity,
webrender_api::units::LayoutVector2D::zero(),
);
@ -341,6 +342,5 @@ fn build_common_item_properties(
// TODO(gw): Make use of the WR backface visibility functionality.
flags: PrimitiveFlags::default(),
hit_info: tag,
item_key: None,
}
}

8
components/layout/sequential.rs
View file

@ -5,6 +5,7 @@
//! Implements sequential traversals over the DOM and flow trees.
use crate::context::LayoutContext;
use crate::display_list::conversions::ToLayout;
use crate::display_list::items::{self, CommonDisplayItem, DisplayItem, DisplayListSection};
use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
use crate::floats::SpeculatedFloatPlacement;
@ -19,6 +20,7 @@ use euclid::default::{Point2D, Rect, Size2D, Vector2D};
use servo_config::opts;
use style::servo::restyle_damage::ServoRestyleDamage;
use webrender_api::units::LayoutPoint;
use webrender_api::PropertyBinding;
pub fn resolve_generated_content(root: &mut dyn Flow, layout_context: &LayoutContext) {
ResolveGeneratedContent::new(&layout_context).traverse(root, 0);
@ -83,8 +85,9 @@ pub fn build_display_list_for_subtree<'a>(
// Create a base rectangle for the page background based on the root
// background color.
let bounds = Rect::new(Point2D::new(Au::new(0), Au::new(0)), client_size);
let base = state.create_base_display_item(
Rect::new(Point2D::new(Au::new(0), Au::new(0)), client_size),
bounds,
flow_root.as_block().fragment.node,
None,
DisplayListSection::BackgroundAndBorders,
@ -92,8 +95,9 @@ pub fn build_display_list_for_subtree<'a>(
state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new(
base,
webrender_api::RectangleDisplayItem {
color: background_color,
color: PropertyBinding::Value(background_color),
common: items::empty_common_item_properties(),
bounds: bounds.to_layout(),
},
)));

14
components/layout_2020/display_list/mod.rs
View file

@ -341,8 +341,10 @@ impl<'a> BuilderForBoxFragment<'a> {
// “The background color is clipped according to the background-clip
// value associated with the bottom-most background image layer.”
let layer_index = b.background_image.0.len() - 1;
let (_, common) = background::painting_area(self, builder, layer_index);
builder.wr.push_rect(&common, rgba(background_color))
let (bounds, common) = background::painting_area(self, builder, layer_index);
builder
.wr
.push_rect(&common, *bounds, rgba(background_color))
}
// Reverse because the property is top layer first, we want to paint bottom layer first.
for (index, image) in b.background_image.0.iter().enumerate().rev() {
@ -587,15 +589,13 @@ fn clip_for_radii(
if radii.is_zero() {
None
} else {
Some(builder.wr.define_clip(
Some(builder.wr.define_clip_rounded_rect(
&builder.current_space_and_clip,
rect,
Some(wr::ComplexClipRegion {
wr::ComplexClipRegion {
rect,
radii,
mode: wr::ClipMode::Clip,
}),
None,
},
))
}
}

2
components/layout_2020/display_list/stacking_context.rs
View file

@ -605,8 +605,6 @@ impl BoxFragment {
self.scrollable_overflow(&containing_block_info.rect)
.to_webrender(),
padding_rect,
vec![], // complex_clips
None, // image_mask
sensitivity,
LayoutVector2D::zero(),
);

4
components/net/image_cache.rs
View file

@ -86,9 +86,7 @@ fn set_webrender_image_key(webrender_api: &WebrenderIpcSender, image: &mut Image
};
let data = webrender_api::ImageData::new(bytes);
let image_key = webrender_api.generate_image_key();
let mut txn = webrender_api::Transaction::new();
txn.add_image(image_key, descriptor, data, None);
webrender_api.update_resources(txn.resource_updates);
webrender_api.add_image(image_key, descriptor, data);
image.id = Some(image_key);
}

11
components/net_traits/lib.rs
View file

@ -32,7 +32,7 @@ use mime::Mime;
use msg::constellation_msg::HistoryStateId;
use servo_url::{ImmutableOrigin, ServoUrl};
use time::precise_time_ns;
use webrender_api::ImageKey;
use webrender_api::{ImageData, ImageDescriptor, ImageKey};
pub mod blob_url_store;
pub mod filemanager_thread;
@ -777,7 +777,7 @@ pub fn http_percent_encode(bytes: &[u8]) -> String {
#[derive(Deserialize, Serialize)]
pub enum WebrenderImageMsg {
UpdateResources(Vec<webrender_api::ResourceUpdate>),
AddImage(ImageKey, ImageDescriptor, ImageData),
GenerateImageKey(IpcSender<ImageKey>),
}
@ -797,8 +797,11 @@ impl WebrenderIpcSender {
receiver.recv().expect("error receiving image key result")
}
pub fn update_resources(&self, updates: Vec<webrender_api::ResourceUpdate>) {
if let Err(e) = self.0.send(WebrenderImageMsg::UpdateResources(updates)) {
pub fn add_image(&self, key: ImageKey, descriptor: ImageDescriptor, data: ImageData) {
if let Err(e) = self
.0
.send(WebrenderImageMsg::AddImage(key, descriptor, data))
{
warn!("Error sending image update: {}", e);
}
}

21
components/script/dom/htmlmediaelement.rs
View file

@ -81,7 +81,7 @@ use net_traits::request::{Destination, Referrer};
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, Metadata};
use net_traits::{NetworkError, ResourceFetchTiming, ResourceTimingType};
use script_layout_interface::HTMLMediaData;
use script_traits::WebrenderIpcSender;
use script_traits::{ImageUpdate, WebrenderIpcSender};
use servo_config::pref;
use servo_media::player::audio::AudioRenderer;
use servo_media::player::video::{VideoFrame, VideoFrameRenderer};
@ -95,9 +95,9 @@ use std::mem;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use time::{self, Duration, Timespec};
use webrender_api::ImageKey;
use webrender_api::{ExternalImageData, ExternalImageId, ExternalImageType, TextureTarget};
use webrender_api::{ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat};
use webrender_api::{ImageKey, Transaction};
#[derive(PartialEq)]
enum FrameStatus {
@ -177,10 +177,10 @@ impl MediaFrameRenderer {
impl VideoFrameRenderer for MediaFrameRenderer {
fn render(&mut self, frame: VideoFrame) {
let mut txn = Transaction::new();
let mut updates = vec![];
if let Some(old_image_key) = mem::replace(&mut self.very_old_frame, self.old_frame.take()) {
txn.delete_image(old_image_key);
updates.push(ImageUpdate::DeleteImage(old_image_key));
}
let descriptor = ImageDescriptor::new(
@ -195,12 +195,11 @@ impl VideoFrameRenderer for MediaFrameRenderer {
if *width == frame.get_width() && *height == frame.get_height() =>
{
if !frame.is_gl_texture() {
txn.update_image(
updates.push(ImageUpdate::UpdateImage(
*image_key,
descriptor,
ImageData::Raw(frame.get_data()),
&webrender_api::DirtyRect::All,
);
));
}
self.current_frame_holder
@ -208,7 +207,7 @@ impl VideoFrameRenderer for MediaFrameRenderer {
.set(frame);
if let Some(old_image_key) = self.old_frame.take() {
txn.delete_image(old_image_key);
updates.push(ImageUpdate::DeleteImage(old_image_key));
}
}
Some((ref mut image_key, ref mut width, ref mut height)) => {
@ -241,7 +240,7 @@ impl VideoFrameRenderer for MediaFrameRenderer {
.get_or_insert_with(|| FrameHolder::new(frame.clone()))
.set(frame);
txn.add_image(new_image_key, descriptor, image_data, None);
updates.push(ImageUpdate::AddImage(new_image_key, descriptor, image_data));
},
None => {
let image_key = self.api.generate_image_key();
@ -265,10 +264,10 @@ impl VideoFrameRenderer for MediaFrameRenderer {
self.current_frame_holder = Some(FrameHolder::new(frame));
txn.add_image(image_key, descriptor, image_data, None);
updates.push(ImageUpdate::AddImage(image_key, descriptor, image_data));
},
}
self.api.update_resources(txn.resource_updates);
self.api.update_images(updates);
}
}

26
components/script_traits/lib.rs
View file

@ -69,8 +69,11 @@ use style_traits::SpeculativePainter;
use webrender_api::units::{
DeviceIntSize, DevicePixel, LayoutPixel, LayoutPoint, LayoutSize, WorldPoint,
};
use webrender_api::{BuiltDisplayList, DocumentId, ExternalScrollId, ImageKey, ScrollClamping};
use webrender_api::{BuiltDisplayListDescriptor, HitTestFlags, HitTestResult, ResourceUpdate};
use webrender_api::{
BuiltDisplayList, DocumentId, ExternalScrollId, ImageData, ImageDescriptor, ImageKey,
ScrollClamping,
};
use webrender_api::{BuiltDisplayListDescriptor, HitTestFlags, HitTestResult};
pub use crate::script_msg::{
DOMMessage, HistoryEntryReplacement, SWManagerMsg, SWManagerSenders, ScopeThings,
@ -1118,7 +1121,7 @@ pub enum WebrenderMsg {
/// provided channel sender.
GenerateImageKey(IpcSender<ImageKey>),
/// Perform a resource update operation.
UpdateResources(Vec<ResourceUpdate>),
UpdateImages(Vec<ImageUpdate>),
}
#[derive(Clone, Deserialize, Serialize)]
@ -1210,9 +1213,20 @@ impl WebrenderIpcSender {
}
/// Perform a resource update operation.
pub fn update_resources(&self, updates: Vec<ResourceUpdate>) {
if let Err(e) = self.0.send(WebrenderMsg::UpdateResources(updates)) {
warn!("error sending resource updates: {}", e);
pub fn update_images(&self, updates: Vec<ImageUpdate>) {
if let Err(e) = self.0.send(WebrenderMsg::UpdateImages(updates)) {
warn!("error sending image updates: {}", e);
}
}
}
#[derive(Deserialize, Serialize)]
/// Serializable image updates that must be performed by WebRender.
pub enum ImageUpdate {
/// Register a new image.
AddImage(ImageKey, ImageDescriptor, ImageData),
/// Delete a previously registered image registration.
DeleteImage(ImageKey),
/// Update an existing image registration.
UpdateImage(ImageKey, ImageDescriptor, ImageData),
}

2
components/servo/Cargo.toml
View file

@ -54,7 +54,7 @@ embedder_traits = {path = "../embedder_traits"}
env_logger = "0.7"
euclid = "0.20"
gfx = {path = "../gfx"}
gleam = "0.9"
gleam = "0.11"
ipc-channel = "0.14"
keyboard-types = "0.4"
layout_thread_2013 = {path = "../layout_thread", optional = true}

13
components/servo/lib.rs
View file

@ -400,14 +400,6 @@ where
let viewport_size = coordinates.viewport.size.to_f32() / device_pixel_ratio;
let (mut webrender, webrender_api_sender) = {
let recorder = if opts.webrender_record {
let record_path = PathBuf::from("wr-record.bin");
let recorder = Box::new(webrender::BinaryRecorder::new(&record_path));
Some(recorder as Box<dyn webrender::ApiRecordingReceiver>)
} else {
None
};
let mut debug_flags = webrender::DebugFlags::empty();
debug_flags.set(webrender::DebugFlags::PROFILER_DBG, opts.webrender_stats);
@ -424,7 +416,6 @@ where
resource_override_path: opts.shaders_dir.clone(),
enable_aa: opts.enable_text_antialiasing,
debug_flags: debug_flags,
recorder: recorder,
precache_flags: if opts.precache_shaders {
ShaderPrecacheFlags::FULL_COMPILE
} else {
@ -465,6 +456,7 @@ where
webrender_gl.clone(),
&mut webrender,
webrender_api_sender.clone(),
webrender_document,
&mut webxr_main_thread,
&mut external_image_handlers,
external_images.clone(),
@ -891,6 +883,7 @@ fn create_constellation(
let font_cache_thread = FontCacheThread::new(
public_resource_threads.sender(),
webrender_api_sender.create_api(),
webrender_document,
);
let initial_state = InitialConstellationState {
@ -1052,6 +1045,7 @@ fn create_webgl_threads(
webrender_gl: Rc<dyn gl::Gl>,
webrender: &mut webrender::Renderer,
webrender_api_sender: webrender_api::RenderApiSender,
webrender_doc: webrender_api::DocumentId,
webxr_main_thread: &mut webxr::MainThreadRegistry,
external_image_handlers: &mut WebrenderExternalImageHandlers,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@ -1075,6 +1069,7 @@ fn create_webgl_threads(
webrender_surfman,
webrender_gl,
webrender_api_sender,
webrender_doc,
external_images,
gl_type,
);

2
components/webgpu/Cargo.toml
View file

@ -17,5 +17,5 @@ log = "0.4"
malloc_size_of = { path = "../malloc_size_of" }
serde = "1.0"
servo_config = {path = "../config"}
smallvec = "0.6"
smallvec = { version = "0.6", features = ["serde"] }
wgpu-core = { version = "0.1.0", git = "https://github.com/gfx-rs/wgpu", features = ["serde"] }