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

Remove old rendering backend.

Browse source 
This removes paint threads, rust-layers dependency, and changes
optional webrender types to be required.

The use_webrender option has been removed, however I've left
the "-w" command line option in place so that wpt
runner can continue to pass that. Once it's removed from there
we can also remove the -w option.

Once this stage is complete, it should be fine to change the
display list building code to generate webrender display
lists directly and avoid the conversion step.
This commit is contained in:
Glenn Watson 2016-10-12 10:13:27 +10:00
parent 4af21e3ae1
commit acfdfd2fa9
55 changed files with 422 additions and 3611 deletions
Download patch file Download diff file Expand all files Collapse all files

31
components/layout/block.rs
View file

@ -31,7 +31,7 @@ use app_units::{Au, MAX_AU};
use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::{BorderPaintingMode, DisplayListBuildState, FragmentDisplayListBuilding};
use display_list_builder::BlockFlowDisplayListBuilding;
use euclid::{Point2D, Rect, Size2D};
use euclid::{Point2D, Size2D};
use floats::{ClearType, FloatKind, Floats, PlacementInfo};
use flow::{self, BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ForceNonfloatedFlag};
use flow::{BLOCK_POSITION_IS_STATIC, CLEARS_LEFT, CLEARS_RIGHT};
@ -64,10 +64,6 @@ use style::properties::ServoComputedValues;
use style::values::computed::{LengthOrNone, LengthOrPercentageOrNone};
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
use util::clamp;
use util::geometry::max_rect;
/// The number of screens of data we're allowed to generate display lists for in each direction.
const DISPLAY_PORT_SIZE_FACTOR: i32 = 8;
/// Information specific to floated blocks.
#[derive(Clone, RustcEncodable)]
@ -1959,7 +1955,7 @@ impl Flow for BlockFlow {
}
}
fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
fn compute_absolute_position(&mut self, _layout_context: &SharedLayoutContext) {
if self.base.flags.contains(NEEDS_LAYER) {
self.fragment.flags.insert(HAS_LAYER)
}
@ -1970,7 +1966,6 @@ impl Flow for BlockFlow {
if self.is_root() {
self.base.clip = ClippingRegion::max();
self.base.stacking_relative_position_of_display_port = max_rect();
}
let transform_style = self.fragment.style().get_used_transform_style();
@ -1983,7 +1978,6 @@ impl Flow for BlockFlow {
(overflow_x::T::auto, _) | (overflow_x::T::scroll, _) |
(_, overflow_x::T::auto) | (_, overflow_x::T::scroll) => {
self.base.clip = ClippingRegion::max();
self.base.stacking_relative_position_of_display_port = max_rect();
}
_ => {}
}
@ -2085,25 +2079,6 @@ impl Flow for BlockFlow {
self.base.stacking_relative_position + relative_offset
};
let stacking_relative_position_of_display_port_for_children =
if is_stacking_context || self.is_root() {
let visible_rect =
match layout_context.visible_rects.get(&self.layer_id()) {
Some(visible_rect) => *visible_rect,
None => Rect::new(Point2D::zero(), layout_context.style_context.viewport_size),
};
let viewport_size = layout_context.style_context.viewport_size;
visible_rect.inflate(viewport_size.width * DISPLAY_PORT_SIZE_FACTOR,
viewport_size.height * DISPLAY_PORT_SIZE_FACTOR)
} else if is_stacking_context {
self.base
.stacking_relative_position_of_display_port
.translate(&-self.base.stacking_relative_position)
} else {
self.base.stacking_relative_position_of_display_port
};
let stacking_relative_border_box =
self.fragment
.stacking_relative_border_box(&self.base.stacking_relative_position,
@ -2168,8 +2143,6 @@ impl Flow for BlockFlow {
flow::mut_base(kid).late_absolute_position_info =
late_absolute_position_info_for_children;
flow::mut_base(kid).stacking_relative_position_of_display_port =
stacking_relative_position_of_display_port_for_children;
// This clipping region is in our coordinate system. The child will fix it up to be in
// its own coordinate system by itself if necessary.

31
components/layout/context.rs
View file

@ -15,7 +15,7 @@ use gfx::font_cache_thread::FontCacheThread;
use gfx::font_context::FontContext;
use gfx_traits::LayerId;
use heapsize::HeapSizeOf;
use ipc_channel::ipc::{self, IpcSharedMemory};
use ipc_channel::ipc;
use net_traits::image::base::Image;
use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread, ImageResponse, ImageState};
use net_traits::image_cache_thread::{ImageOrMetadataAvailable, UsePlaceholder};
@ -196,36 +196,27 @@ impl SharedLayoutContext {
pub fn get_webrender_image_for_url(&self,
url: &Url,
use_placeholder: UsePlaceholder,
fetch_image_data_as_well: bool)
-> Option<(WebRenderImageInfo, Option<IpcSharedMemory>)> {
if !fetch_image_data_as_well {
let webrender_image_cache = self.webrender_image_cache.read().unwrap();
if let Some(existing_webrender_image) =
webrender_image_cache.get(&((*url).clone(), use_placeholder)) {
return Some(((*existing_webrender_image).clone(), None))
}
use_placeholder: UsePlaceholder)
-> Option<WebRenderImageInfo> {
if let Some(existing_webrender_image) = self.webrender_image_cache
.read()
.unwrap()
.get(&((*url).clone(), use_placeholder)) {
return Some((*existing_webrender_image).clone())
}
match self.get_or_request_image_or_meta((*url).clone(), use_placeholder) {
Some(ImageOrMetadataAvailable::ImageAvailable(image)) => {
let image_info = WebRenderImageInfo::from_image(&*image);
if image_info.key.is_none() {
let bytes = if !fetch_image_data_as_well {
None
} else {
Some(image.bytes.clone())
};
Some((image_info, bytes))
} else if !fetch_image_data_as_well {
Some(image_info)
} else {
let mut webrender_image_cache = self.webrender_image_cache
.write()
.unwrap();
webrender_image_cache.insert(((*url).clone(), use_placeholder),
image_info);
Some((image_info, None))
} else {
Some((image_info, Some(image.bytes.clone())))
Some(image_info)
}
}
None | Some(ImageOrMetadataAvailable::MetadataAvailable(_)) => None,

82
components/layout/display_list_builder.rs
View file

@ -25,10 +25,9 @@ use gfx::display_list::{BLUR_INFLATION_FACTOR, BaseDisplayItem, BorderDisplayIte
use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClippingRegion};
use gfx::display_list::{DisplayItem, DisplayItemMetadata, DisplayListSection, GradientDisplayItem};
use gfx::display_list::{GradientStop, IframeDisplayItem, ImageDisplayItem, WebGLDisplayItem};
use gfx::display_list::{LayerInfo, LayeredItem, LineDisplayItem, OpaqueNode};
use gfx::display_list::{LayerInfo, LineDisplayItem, OpaqueNode};
use gfx::display_list::{SolidColorDisplayItem, StackingContext, StackingContextType};
use gfx::display_list::{TextDisplayItem, TextOrientation, WebRenderImageInfo};
use gfx::paint_thread::THREAD_TINT_COLORS;
use gfx_traits::{ScrollPolicy, StackingContextId, color};
use inline::{FIRST_FRAGMENT_OF_ELEMENT, InlineFlow, LAST_FRAGMENT_OF_ELEMENT};
use ipc_channel::ipc;
@ -60,6 +59,17 @@ use table_cell::CollapsedBordersForCell;
use url::Url;
use util::opts;
static THREAD_TINT_COLORS: [Color; 8] = [
Color { r: 6.0 / 255.0, g: 153.0 / 255.0, b: 198.0 / 255.0, a: 0.7 },
Color { r: 255.0 / 255.0, g: 212.0 / 255.0, b: 83.0 / 255.0, a: 0.7 },
Color { r: 116.0 / 255.0, g: 29.0 / 255.0, b: 109.0 / 255.0, a: 0.7 },
Color { r: 204.0 / 255.0, g: 158.0 / 255.0, b: 199.0 / 255.0, a: 0.7 },
Color { r: 242.0 / 255.0, g: 46.0 / 255.0, b: 121.0 / 255.0, a: 0.7 },
Color { r: 116.0 / 255.0, g: 203.0 / 255.0, b: 196.0 / 255.0, a: 0.7 },
Color { r: 255.0 / 255.0, g: 249.0 / 255.0, b: 201.0 / 255.0, a: 0.7 },
Color { r: 137.0 / 255.0, g: 196.0 / 255.0, b: 78.0 / 255.0, a: 0.7 },
];
fn get_cyclic<T>(arr: &[T], index: usize) -> &T {
&arr[index % arr.len()]
}
@ -230,8 +240,6 @@ pub trait FragmentDisplayListBuilding {
/// * `relative_containing_block_size`: The size of the containing block that
/// `position: relative` makes use of.
/// * `clip`: The region to clip the display items to.
/// * `stacking_relative_display_port`: The position and size of the display port with respect
/// to the nearest ancestor stacking context.
fn build_display_list(&mut self,
state: &mut DisplayListBuildState,
stacking_relative_flow_origin: &Point2D<Au>,
@ -239,8 +247,7 @@ pub trait FragmentDisplayListBuilding {
relative_containing_block_mode: WritingMode,
border_painting_mode: BorderPaintingMode,
display_list_section: DisplayListSection,
clip: &ClippingRegion,
stacking_relative_display_port: &Rect<Au>);
clip: &ClippingRegion);
/// Adjusts the clipping region for all descendants of this fragment as appropriate.
fn adjust_clipping_region_for_children(&self,
@ -497,13 +504,11 @@ impl FragmentDisplayListBuilding for Fragment {
image_url: &Url,
index: usize) {
let background = style.get_background();
let fetch_image_data_as_well = !opts::get().use_webrender;
let webrender_image = state.shared_layout_context
.get_webrender_image_for_url(image_url,
UsePlaceholder::No,
fetch_image_data_as_well);
UsePlaceholder::No);
if let Some((webrender_image, image_data)) = webrender_image {
if let Some(webrender_image) = webrender_image {
debug!("(building display list) building background image");
// Use `background-size` to get the size.
@ -633,7 +638,7 @@ impl FragmentDisplayListBuilding for Fragment {
state.add_display_item(DisplayItem::ImageClass(box ImageDisplayItem {
base: base,
webrender_image: webrender_image,
image_data: image_data.map(Arc::new),
image_data: None,
stretch_size: stretch_size,
tile_spacing: tile_spacing,
image_rendering: style.get_inheritedbox().image_rendering.clone(),
@ -1080,8 +1085,7 @@ impl FragmentDisplayListBuilding for Fragment {
relative_containing_block_mode: WritingMode,
border_painting_mode: BorderPaintingMode,
display_list_section: DisplayListSection,
clip: &ClippingRegion,
stacking_relative_display_port: &Rect<Au>) {
clip: &ClippingRegion) {
self.restyle_damage.remove(REPAINT);
if self.style().get_inheritedbox().visibility != visibility::T::visible {
return
@ -1102,14 +1106,6 @@ impl FragmentDisplayListBuilding for Fragment {
stacking_relative_flow_origin,
self);
// webrender deals with all culling via aabb
if !opts::get().use_webrender {
if !stacking_relative_border_box.intersects(stacking_relative_display_port) {
debug!("Fragment::build_display_list: outside display port");
return
}
}
// Check the clip rect. If there's nothing to render at all, don't even construct display
// list items.
let empty_rect = !clip.might_intersect_rect(&stacking_relative_border_box);
@ -1270,17 +1266,7 @@ impl FragmentDisplayListBuilding for Fragment {
iframe: fragment_info.pipeline_id,
});
if opts::get().use_webrender {
state.add_display_item(item);
} else {
state.add_display_item(DisplayItem::LayeredItemClass(box LayeredItem {
item: item,
layer_info: LayerInfo::new(self.layer_id(),
ScrollPolicy::Scrollable,
Some(fragment_info.pipeline_id),
color::transparent()),
}));
}
state.add_display_item(item);
}
}
SpecificFragmentInfo::Image(ref mut image_fragment) => {
@ -1311,7 +1297,6 @@ impl FragmentDisplayListBuilding for Fragment {
let computed_width = canvas_fragment_info.canvas_inline_size().to_px();
let computed_height = canvas_fragment_info.canvas_block_size().to_px();
let layer_id = self.layer_id();
let canvas_data = match canvas_fragment_info.ipc_renderer {
Some(ref ipc_renderer) => {
let ipc_renderer = ipc_renderer.lock().unwrap();
@ -1338,7 +1323,7 @@ impl FragmentDisplayListBuilding for Fragment {
width: computed_width as u32,
height: computed_height as u32,
format: PixelFormat::RGBA8,
key: canvas_data.image_key,
key: Some(canvas_data.image_key),
},
stretch_size: stacking_relative_content_box.size,
tile_spacing: Size2D::zero(),
@ -1353,17 +1338,7 @@ impl FragmentDisplayListBuilding for Fragment {
}
};
if opts::get().use_webrender {
state.add_display_item(display_item);
} else {
state.add_display_item(DisplayItem::LayeredItemClass(box LayeredItem {
item: display_item,
layer_info: LayerInfo::new(layer_id,
ScrollPolicy::Scrollable,
None,
color::transparent()),
}));
}
state.add_display_item(display_item);
}
}
SpecificFragmentInfo::UnscannedText(_) => {
@ -1381,7 +1356,6 @@ impl FragmentDisplayListBuilding for Fragment {
scroll_policy: ScrollPolicy,
mode: StackingContextCreationMode)
-> StackingContext {
let use_webrender = opts::get().use_webrender;
let border_box = match mode {
StackingContextCreationMode::InnerScrollWrapper => {
Rect::new(Point2D::zero(), base_flow.overflow.scroll.size)
@ -1396,10 +1370,7 @@ impl FragmentDisplayListBuilding for Fragment {
}
};
let overflow = match mode {
StackingContextCreationMode::InnerScrollWrapper if !use_webrender => {
Rect::new(Point2D::zero(), base_flow.overflow.paint.size)
}
StackingContextCreationMode::InnerScrollWrapper if use_webrender => {
StackingContextCreationMode::InnerScrollWrapper => {
Rect::new(Point2D::zero(), base_flow.overflow.scroll.size)
}
StackingContextCreationMode::OuterScrollWrapper => {
@ -1874,8 +1845,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
.relative_containing_block_mode,
border_painting_mode,
background_border_section,
&self.base.clip,
&self.base.stacking_relative_position_of_display_port);
&self.base.clip);
self.base.build_display_items_for_debugging_tint(state, self.fragment.node);
}
@ -1982,8 +1952,7 @@ impl InlineFlowDisplayListBuilding for InlineFlow {
.relative_containing_block_mode,
BorderPaintingMode::Separate,
DisplayListSection::Content,
&self.base.clip,
&self.base.stacking_relative_position_of_display_port);
&self.base.clip);
}
fn build_display_list_for_inline(&mut self, state: &mut DisplayListBuildState) {
@ -2039,10 +2008,7 @@ impl ListItemFlowDisplayListBuilding for ListItemFlow {
.relative_containing_block_mode,
BorderPaintingMode::Separate,
DisplayListSection::Content,
&self.block_flow.base.clip,
&self.block_flow
.base
.stacking_relative_position_of_display_port);
&self.block_flow.base.clip);
}
// Draw the rest of the block.

9
components/layout/flow.rs
View file

@ -29,7 +29,7 @@ use app_units::Au;
use block::{BlockFlow, FormattingContextType};
use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState;
use euclid::{Point2D, Rect, Size2D};
use euclid::{Point2D, Size2D};
use floats::{Floats, SpeculatedFloatPlacement};
use flow_list::{FlowList, MutFlowListIterator};
use flow_ref::{self, FlowRef, WeakFlowRef};
@ -940,12 +940,6 @@ pub struct BaseFlow {
/// this is in the flow's own coordinate system.
pub clip: ClippingRegion,
/// The stacking-relative position of the display port.
///
/// FIXME(pcwalton): This might be faster as an Arc, since this varies only
/// per-stacking-context.
pub stacking_relative_position_of_display_port: Rect<Au>,
/// The writing mode for this flow.
pub writing_mode: WritingMode,
@ -1124,7 +1118,6 @@ impl BaseFlow {
early_absolute_position_info: EarlyAbsolutePositionInfo::new(writing_mode),
late_absolute_position_info: LateAbsolutePositionInfo::new(),
clip: ClippingRegion::max(),
stacking_relative_position_of_display_port: Rect::zero(),
flags: flags,
writing_mode: writing_mode,
thread_id: 0,

6
components/layout/inline.rs
View file

@ -1566,8 +1566,6 @@ impl Flow for InlineFlow {
block_flow.base.stacking_relative_position =
stacking_relative_content_box.origin;
block_flow.base.stacking_relative_position_of_display_port =
self.base.stacking_relative_position_of_display_port;
// Write the clip in our coordinate system into the child flow. (The kid will
// fix it up to be in its own coordinate system if necessary.)
@ -1581,8 +1579,6 @@ impl Flow for InlineFlow {
block_flow.base.stacking_relative_position =
stacking_relative_border_box.origin;
block_flow.base.stacking_relative_position_of_display_port =
self.base.stacking_relative_position_of_display_port;
// As above, this is in our coordinate system for now.
block_flow.base.clip = self.base.clip.clone()
@ -1602,8 +1598,6 @@ impl Flow for InlineFlow {
block_flow.base.stacking_relative_position =
stacking_relative_border_box.origin;
block_flow.base.stacking_relative_position_of_display_port =
self.base.stacking_relative_position_of_display_port;
// As above, this is in our coordinate system for now.
block_flow.base.clip = self.base.clip.clone()

2
components/layout/webrender_helpers.rs
View file

@ -411,7 +411,7 @@ impl WebRenderDisplayItemConverter for DisplayItem {
builder.push_text(item.base.bounds.to_rectf(),
item.base.clip.to_clip_region(frame_builder),
glyphs,
item.text_run.font_key.expect("Font not added to webrender!"),
item.text_run.font_key,
item.text_color.to_colorf(),
item.text_run.actual_pt_size,
item.blur_radius,