Skip to content

/ servo

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Deal with changes to the WebRender API #14200

Merged
merged 2 commits into from Nov 16, 2016
+127 −243
Merged

Deal with changes to the WebRender API #14200

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
e164e87
Deal with changes to the WebRender API
mrobinson Nov 8, 2016
386567e
Try to use reftest-wait to make iframe tests less brittle
mrobinson Nov 15, 2016
File filter...
Filter file types
Jump to…
Jump to file
Failed to load files.

Always

Just for now

238 components/layout/webrender_helpers.rs
View file
Open in desktop
@@ -10,46 +10,20 @@
use app_units::Au;
use euclid::{Matrix4D, Point2D, Rect, Size2D, TypedRect};
use gfx::display_list::{BorderRadii, BoxShadowClipMode, ClippingRegion};
use gfx::display_list::{DisplayItem, DisplayList, DisplayListTraversal};
use gfx::display_list::{StackingContext, StackingContextType};
use gfx::display_list::{DisplayItem, DisplayList, DisplayListTraversal, StackingContextType};
use gfx_traits::{FragmentType, ScrollPolicy, StackingContextId, ScrollRootId};
use style::computed_values::{image_rendering, mix_blend_mode};
use style::computed_values::filter::{self, Filter};
use style::values::computed::BorderStyle;
use webrender_traits::{self, AuxiliaryListsBuilder, DisplayListId, PipelineId};

trait WebRenderStackingContextConverter {
fn convert_to_webrender<'a>(&self,
traversal: &mut DisplayListTraversal<'a>,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
frame_builder: &mut WebRenderFrameBuilder,
scroll_layer_id: Option<webrender_traits::ScrollLayerId>)
-> webrender_traits::StackingContextId;

fn convert_children_to_webrender<'a>(&self,
traversal: &mut DisplayListTraversal<'a>,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
builder: &mut webrender_traits::DisplayListBuilder,
frame_builder: &mut WebRenderFrameBuilder,
force_positioned_stacking_level: bool);
}
use webrender_traits::{self, AuxiliaryListsBuilder, BuiltDisplayList, DisplayListBuilder, PipelineId};

pub trait WebRenderDisplayListConverter {
fn convert_to_webrender(&self,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
frame_builder: &mut WebRenderFrameBuilder)
-> webrender_traits::StackingContextId;
fn convert_to_webrender(&self, frame_builder: &mut WebRenderFrameBuilder) -> BuiltDisplayList;
}

trait WebRenderDisplayItemConverter {
fn convert_to_webrender(&self,
builder: &mut webrender_traits::DisplayListBuilder,
builder: &mut DisplayListBuilder,
frame_builder: &mut WebRenderFrameBuilder);
}

@@ -73,7 +47,6 @@ impl ToBorderStyle for BorderStyle {
}
}
}

trait ToBoxShadowClipMode {
fn to_clip_mode(&self) -> webrender_traits::BoxShadowClipMode;
}
@@ -222,128 +195,20 @@ impl ToFilterOps for filter::T {
}
}

impl WebRenderStackingContextConverter for StackingContext {
fn convert_children_to_webrender<'a>(&self,
traversal: &mut DisplayListTraversal<'a>,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
builder: &mut webrender_traits::DisplayListBuilder,
frame_builder: &mut WebRenderFrameBuilder,
_force_positioned_stacking_level: bool) {
while let Some(item) = traversal.next() {
match item {
&DisplayItem::PushStackingContext(ref stacking_context_item) => {
let stacking_context = &stacking_context_item.stacking_context;
debug_assert!(stacking_context.context_type == StackingContextType::Real);
builder.push_stacking_context(
stacking_context.convert_to_webrender(traversal,
api,
pipeline_id,
epoch,
frame_builder,
None));
}
&DisplayItem::PushScrollRoot(ref item) => {
let stacking_context = StackingContext::new(
StackingContextId::new(0),
StackingContextType::Real,
&item.scroll_root.clip,
&TypedRect::new(Point2D::zero(), item.scroll_root.size),
0,
filter::T::new(Vec::new()),
mix_blend_mode::T::normal,
Matrix4D::identity(),
Matrix4D::identity(),
true,
ScrollPolicy::Scrollable,
ScrollRootId::root());
let scroll_layer_id =
Some(frame_builder.next_scroll_layer_id(item.scroll_root.id));
builder.push_stacking_context(
stacking_context.convert_to_webrender(traversal,
api,
pipeline_id,
epoch,
frame_builder,
scroll_layer_id));
}
&DisplayItem::PopStackingContext(_) | &DisplayItem::PopScrollRoot(_) => return,
_ => item.convert_to_webrender(builder, frame_builder),
}
}
}

fn convert_to_webrender<'a>(&self,
traversal: &mut DisplayListTraversal<'a>,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
frame_builder: &mut WebRenderFrameBuilder,
scroll_layer_id: Option<webrender_traits::ScrollLayerId>)
-> webrender_traits::StackingContextId {
let webrender_scroll_policy = match self.scroll_policy {
ScrollPolicy::Scrollable => webrender_traits::ScrollPolicy::Scrollable,
ScrollPolicy::FixedPosition => webrender_traits::ScrollPolicy::Fixed,
};

let mut sc =
webrender_traits::StackingContext::new(scroll_layer_id,
webrender_scroll_policy,
self.bounds.to_rectf(),
self.overflow.to_rectf(),
self.z_index,
&self.transform,
&self.perspective,
self.establishes_3d_context,
self.blend_mode.to_blend_mode(),
self.filters.to_filter_ops(),
&mut frame_builder.auxiliary_lists_builder);

let mut builder = webrender_traits::DisplayListBuilder::new();
self.convert_children_to_webrender(traversal,
api,
pipeline_id,
epoch,
&mut builder,
frame_builder,
false);

frame_builder.add_display_list(api, builder.finalize(), &mut sc);
frame_builder.add_stacking_context(api, pipeline_id, sc)
}
}

impl WebRenderDisplayListConverter for DisplayList {
fn convert_to_webrender(&self,
api: &mut webrender_traits::RenderApi,
pipeline_id: webrender_traits::PipelineId,
epoch: webrender_traits::Epoch,
frame_builder: &mut WebRenderFrameBuilder)
-> webrender_traits::StackingContextId {
let mut traversal = DisplayListTraversal::new(self);
let item = traversal.next();
match item {
Some(&DisplayItem::PushStackingContext(ref stacking_context_item)) => {
let stacking_context = &stacking_context_item.stacking_context;
let scroll_layer_id =
Some(frame_builder.next_scroll_layer_id(ScrollRootId::root()));
stacking_context.convert_to_webrender(&mut traversal,
api,
pipeline_id,
epoch,
frame_builder,
scroll_layer_id)
}
_ => unreachable!("DisplayList did not start with StackingContext."),

fn convert_to_webrender(&self, frame_builder: &mut WebRenderFrameBuilder) -> BuiltDisplayList {
let traversal = DisplayListTraversal::new(self);
let mut builder = DisplayListBuilder::new();
for item in traversal {
item.convert_to_webrender(&mut builder, frame_builder);
}
builder.finalize()
}
}

impl WebRenderDisplayItemConverter for DisplayItem {
fn convert_to_webrender(&self,
builder: &mut webrender_traits::DisplayListBuilder,
builder: &mut DisplayListBuilder,
frame_builder: &mut WebRenderFrameBuilder) {
match *self {
DisplayItem::SolidColor(ref item) => {
@@ -472,19 +337,60 @@ impl WebRenderDisplayItemConverter for DisplayItem {
item.base.clip.to_clip_region(frame_builder),
pipeline_id);
}
DisplayItem::PushStackingContext(_) |
DisplayItem::PopStackingContext(_) |
DisplayItem::PushScrollRoot(_) |
DisplayItem::PopScrollRoot(_) =>
unreachable!("Tried to convert a scroll root or stacking context structure item."),
DisplayItem::PushStackingContext(ref item) => {
let stacking_context = &item.stacking_context;
debug_assert!(stacking_context.context_type == StackingContextType::Real);

let webrender_scroll_policy = match stacking_context.scroll_policy {
ScrollPolicy::Scrollable => webrender_traits::ScrollPolicy::Scrollable,
ScrollPolicy::FixedPosition => webrender_traits::ScrollPolicy::Fixed,
};

let scroll_layer_id = if stacking_context.id == StackingContextId::root() {
Some(frame_builder.next_scroll_layer_id(ScrollRootId::root()))
} else {
None
};

let context =
webrender_traits::StackingContext::new(
scroll_layer_id,
webrender_scroll_policy,
stacking_context.bounds.to_rectf(),
stacking_context.overflow.to_rectf(),
stacking_context.z_index,
&stacking_context.transform,
&stacking_context.perspective,
stacking_context.establishes_3d_context,
stacking_context.blend_mode.to_blend_mode(),
stacking_context.filters.to_filter_ops(),
&mut frame_builder.auxiliary_lists_builder);
builder.push_stacking_context(context);

}
DisplayItem::PopStackingContext(_) => builder.pop_stacking_context(),
DisplayItem::PushScrollRoot(ref item) => {
let overflow = TypedRect::new(Point2D::zero(), item.scroll_root.size);
let context = webrender_traits::StackingContext::new(
Some(frame_builder.next_scroll_layer_id(item.scroll_root.id)),
webrender_traits::ScrollPolicy::Scrollable,
item.scroll_root.clip.to_rectf(),
overflow.to_rectf(),
0,
&Matrix4D::identity(),
&Matrix4D::identity(),
true,
mix_blend_mode::T::normal.to_blend_mode(),
filter::T::new(Vec::new()).to_filter_ops(),
&mut frame_builder.auxiliary_lists_builder);
builder.push_stacking_context(context);
}
DisplayItem::PopScrollRoot(_) => builder.pop_stacking_context(),
}
}
}

pub struct WebRenderFrameBuilder {
pub stacking_contexts: Vec<(webrender_traits::StackingContextId,
webrender_traits::StackingContext)>,
pub display_lists: Vec<(DisplayListId, webrender_traits::BuiltDisplayList)>,
pub auxiliary_lists_builder: AuxiliaryListsBuilder,
pub root_pipeline_id: PipelineId,
pub next_scroll_layer_id: usize,
@@ -493,36 +399,12 @@ pub struct WebRenderFrameBuilder {
impl WebRenderFrameBuilder {
pub fn new(root_pipeline_id: PipelineId) -> WebRenderFrameBuilder {
WebRenderFrameBuilder {
stacking_contexts: vec![],
display_lists: vec![],
auxiliary_lists_builder: AuxiliaryListsBuilder::new(),
root_pipeline_id: root_pipeline_id,
next_scroll_layer_id: 0,
}
}

pub fn add_stacking_context(&mut self,
api: &mut webrender_traits::RenderApi,
pipeline_id: PipelineId,
stacking_context: webrender_traits::StackingContext)
-> webrender_traits::StackingContextId {
assert!(pipeline_id == self.root_pipeline_id);
let id = api.next_stacking_context_id();
self.stacking_contexts.push((id, stacking_context));
id
}

pub fn add_display_list(&mut self,
api: &mut webrender_traits::RenderApi,
display_list: webrender_traits::BuiltDisplayList,
stacking_context: &mut webrender_traits::StackingContext)
-> DisplayListId {
let id = api.next_display_list_id();
stacking_context.display_lists.push(id);
self.display_lists.push((id, display_list));
id
}

pub fn next_scroll_layer_id(&mut self,
scroll_root_id: ScrollRootId)
-> webrender_traits::ScrollLayerId {
30 components/layout_thread/lib.rs
View file
Open in desktop
@@ -939,33 +939,25 @@ impl LayoutThread {

debug!("Layout done!");

self.epoch.next();

// TODO: Avoid the temporary conversion and build webrender sc/dl directly!
let Epoch(epoch_number) = self.epoch;
let epoch = webrender_traits::Epoch(epoch_number);
let pipeline_id = self.id.to_webrender();

// TODO(gw) For now only create a root scrolling layer!
let mut frame_builder = WebRenderFrameBuilder::new(pipeline_id);
let sc_id = rw_data.display_list.as_ref().unwrap().convert_to_webrender(
&mut self.webrender_api,
pipeline_id,
epoch,
let built_display_list = rw_data.display_list.as_ref().unwrap().convert_to_webrender(
&mut frame_builder);
let root_background_color = get_root_flow_background_color(layout_root);

let viewport_size = Size2D::new(self.viewport_size.width.to_f32_px(),
self.viewport_size.height.to_f32_px());

self.webrender_api.set_root_stacking_context(sc_id,
root_background_color,
epoch,
pipeline_id,
viewport_size,
frame_builder.stacking_contexts,
frame_builder.display_lists,
frame_builder.auxiliary_lists_builder.finalize());
self.epoch.next();
let Epoch(epoch_number) = self.epoch;

self.webrender_api.set_root_display_list(
get_root_flow_background_color(layout_root),
webrender_traits::Epoch(epoch_number),
pipeline_id,
viewport_size,
built_display_list,
frame_builder.auxiliary_lists_builder.finalize());
});
}

ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.