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

Auto merge of #13029 - servo:flowref, r=nox

Browse source 
Use &mut Flow more.

The double indirection in `&mut FlowRef` is not useful.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/13029)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2016-08-25 04:52:24 -05:00 • committed by GitHub
commit d29f61af31
4 changed files with 44 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/layout/parallel.rs
View file

@ -10,7 +10,7 @@
use context::{LayoutContext, SharedLayoutContext}; use context::{LayoutContext, SharedLayoutContext};
use flow::{self, Flow, MutableFlowUtils, PostorderFlowTraversal, PreorderFlowTraversal}; use flow::{self, Flow, MutableFlowUtils, PostorderFlowTraversal, PreorderFlowTraversal};
use flow_ref::{self, FlowRef}; use flow_ref::FlowRef;
use profile_traits::time::{self, TimerMetadata, profile}; use profile_traits::time::{self, TimerMetadata, profile};
use std::mem; use std::mem;
use std::sync::atomic::{AtomicIsize, Ordering}; use std::sync::atomic::{AtomicIsize, Ordering};
@ -220,7 +220,7 @@ fn assign_block_sizes_and_store_overflow(
} }
pub fn traverse_flow_tree_preorder( pub fn traverse_flow_tree_preorder(
root: &mut FlowRef, root: &mut Flow,
profiler_metadata: Option<TimerMetadata>, profiler_metadata: Option<TimerMetadata>,
time_profiler_chan: time::ProfilerChan, time_profiler_chan: time::ProfilerChan,
shared_layout_context: &SharedLayoutContext, shared_layout_context: &SharedLayoutContext,
@ -228,7 +228,7 @@ pub fn traverse_flow_tree_preorder(
if opts::get().bubble_inline_sizes_separately { if opts::get().bubble_inline_sizes_separately {
let layout_context = LayoutContext::new(shared_layout_context); let layout_context = LayoutContext::new(shared_layout_context);
let bubble_inline_sizes = BubbleISizes { layout_context: &layout_context }; let bubble_inline_sizes = BubbleISizes { layout_context: &layout_context };
flow_ref::deref_mut(root).traverse_postorder(&bubble_inline_sizes); root.traverse_postorder(&bubble_inline_sizes);
} }
run_queue_with_custom_work_data_type(queue, |queue| { run_queue_with_custom_work_data_type(queue, |queue| {
@ -236,7 +236,7 @@ pub fn traverse_flow_tree_preorder(
time_profiler_chan, || { time_profiler_chan, || {
queue.push(WorkUnit { queue.push(WorkUnit {
fun: assign_inline_sizes, fun: assign_inline_sizes,
data: (box vec![mut_owned_flow_to_unsafe_flow(root)], 0), data: (box vec![borrowed_flow_to_unsafe_flow(root)], 0),
}) })
}); });
}, shared_layout_context); }, shared_layout_context);

17
components/layout/query.rs
View file

@ -9,8 +9,7 @@ use construct::ConstructionResult;
use euclid::point::Point2D; use euclid::point::Point2D;
use euclid::rect::Rect; use euclid::rect::Rect;
use euclid::size::Size2D; use euclid::size::Size2D;
use flow; use flow::{self, Flow};
use flow_ref::FlowRef;
use fragment::{Fragment, FragmentBorderBoxIterator, SpecificFragmentInfo}; use fragment::{Fragment, FragmentBorderBoxIterator, SpecificFragmentInfo};
use gfx::display_list::{DisplayItemMetadata, DisplayList, OpaqueNode, ScrollOffsetMap}; use gfx::display_list::{DisplayItemMetadata, DisplayList, OpaqueNode, ScrollOffsetMap};
use gfx_traits::LayerId; use gfx_traits::LayerId;
@ -375,7 +374,7 @@ impl FragmentBorderBoxIterator for MarginRetrievingFragmentBorderBoxIterator {
} }
pub fn process_content_box_request<N: LayoutNode>( pub fn process_content_box_request<N: LayoutNode>(
requested_node: N, layout_root: &mut FlowRef) -> Rect<Au> { requested_node: N, layout_root: &mut Flow) -> Rect<Au> {
// FIXME(pcwalton): This has not been updated to handle the stacking context relative // FIXME(pcwalton): This has not been updated to handle the stacking context relative
// stuff. So the position is wrong in most cases. // stuff. So the position is wrong in most cases.
let mut iterator = UnioningFragmentBorderBoxIterator::new(requested_node.opaque()); let mut iterator = UnioningFragmentBorderBoxIterator::new(requested_node.opaque());
@ -386,7 +385,7 @@ pub fn process_content_box_request<N: LayoutNode>(
} }
} }
pub fn process_content_boxes_request<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef) pub fn process_content_boxes_request<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
-> Vec<Rect<Au>> { -> Vec<Rect<Au>> {
// FIXME(pcwalton): This has not been updated to handle the stacking context relative // FIXME(pcwalton): This has not been updated to handle the stacking context relative
// stuff. So the position is wrong in most cases. // stuff. So the position is wrong in most cases.
@ -581,7 +580,7 @@ impl FragmentBorderBoxIterator for ParentOffsetBorderBoxIterator {
} }
} }
pub fn process_node_geometry_request<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef) pub fn process_node_geometry_request<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
-> Rect<i32> { -> Rect<i32> {
let mut iterator = FragmentLocatingFragmentIterator::new(requested_node.opaque()); let mut iterator = FragmentLocatingFragmentIterator::new(requested_node.opaque());
sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator); sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
@ -593,7 +592,7 @@ pub fn process_node_layer_id_request<N: LayoutNode>(requested_node: N) -> LayerI
layout_node.layer_id() layout_node.layer_id()
} }
pub fn process_node_scroll_area_request< N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef) pub fn process_node_scroll_area_request< N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
-> Rect<i32> { -> Rect<i32> {
let mut iterator = UnioningFragmentScrollAreaIterator::new(requested_node.opaque()); let mut iterator = UnioningFragmentScrollAreaIterator::new(requested_node.opaque());
sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator); sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
@ -643,7 +642,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
style_context: &'a C, style_context: &'a C,
pseudo: &Option<PseudoElement>, pseudo: &Option<PseudoElement>,
property: &Atom, property: &Atom,
layout_root: &mut FlowRef) -> Option<String> layout_root: &mut Flow) -> Option<String>
where N: LayoutNode, where N: LayoutNode,
C: StyleContext<'a> C: StyleContext<'a>
{ {
@ -695,7 +694,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
fn used_value_for_position_property<N: LayoutNode>( fn used_value_for_position_property<N: LayoutNode>(
layout_node: N::ConcreteThreadSafeLayoutNode, layout_node: N::ConcreteThreadSafeLayoutNode,
layout_root: &mut FlowRef, layout_root: &mut Flow,
requested_node: N, requested_node: N,
property: &Atom) -> Option<String> { property: &Atom) -> Option<String> {
let maybe_data = layout_node.borrow_layout_data(); let maybe_data = layout_node.borrow_layout_data();
@ -774,7 +773,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
} }
} }
pub fn process_offset_parent_query<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef) pub fn process_offset_parent_query<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
-> OffsetParentResponse { -> OffsetParentResponse {
let mut iterator = ParentOffsetBorderBoxIterator::new(requested_node.opaque()); let mut iterator = ParentOffsetBorderBoxIterator::new(requested_node.opaque());
sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator); sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);

20
components/layout/sequential.rs
View file

@ -12,7 +12,6 @@ use floats::SpeculatedFloatPlacement;
use flow::IS_ABSOLUTELY_POSITIONED; use flow::IS_ABSOLUTELY_POSITIONED;
use flow::{PostorderFlowTraversal, PreorderFlowTraversal}; use flow::{PostorderFlowTraversal, PreorderFlowTraversal};
use flow::{self, Flow, ImmutableFlowUtils, InorderFlowTraversal, MutableFlowUtils}; use flow::{self, Flow, ImmutableFlowUtils, InorderFlowTraversal, MutableFlowUtils};
use flow_ref::{self, FlowRef};
use fragment::FragmentBorderBoxIterator; use fragment::FragmentBorderBoxIterator;
use generated_content::ResolveGeneratedContent; use generated_content::ResolveGeneratedContent;
use gfx::display_list::{DisplayItem, StackingContext}; use gfx::display_list::{DisplayItem, StackingContext};
@ -23,7 +22,7 @@ use util::opts;
pub use style::sequential::traverse_dom; pub use style::sequential::traverse_dom;
pub fn resolve_generated_content(root: &mut FlowRef, shared_layout_context: &SharedLayoutContext) { pub fn resolve_generated_content(root: &mut Flow, shared_layout_context: &SharedLayoutContext) {
fn doit(flow: &mut Flow, level: u32, traversal: &mut ResolveGeneratedContent) { fn doit(flow: &mut Flow, level: u32, traversal: &mut ResolveGeneratedContent) {
if !traversal.should_process(flow) { if !traversal.should_process(flow) {
return return
@ -38,10 +37,10 @@ pub fn resolve_generated_content(root: &mut FlowRef, shared_layout_context: &Sha
let layout_context = LayoutContext::new(shared_layout_context); let layout_context = LayoutContext::new(shared_layout_context);
let mut traversal = ResolveGeneratedContent::new(&layout_context); let mut traversal = ResolveGeneratedContent::new(&layout_context);
doit(flow_ref::deref_mut(root), 0, &mut traversal) doit(root, 0, &mut traversal)
} }
pub fn traverse_flow_tree_preorder(root: &mut FlowRef, pub fn traverse_flow_tree_preorder(root: &mut Flow,
shared_layout_context: &SharedLayoutContext) { shared_layout_context: &SharedLayoutContext) {
fn doit(flow: &mut Flow, fn doit(flow: &mut Flow,
assign_inline_sizes: AssignISizes, assign_inline_sizes: AssignISizes,
@ -61,8 +60,6 @@ pub fn traverse_flow_tree_preorder(root: &mut FlowRef,
let layout_context = LayoutContext::new(shared_layout_context); let layout_context = LayoutContext::new(shared_layout_context);
let root = flow_ref::deref_mut(root);
if opts::get().bubble_inline_sizes_separately { if opts::get().bubble_inline_sizes_separately {
let bubble_inline_sizes = BubbleISizes { layout_context: &layout_context }; let bubble_inline_sizes = BubbleISizes { layout_context: &layout_context };
{ {
@ -77,11 +74,10 @@ pub fn traverse_flow_tree_preorder(root: &mut FlowRef,
doit(root, assign_inline_sizes, assign_block_sizes); doit(root, assign_inline_sizes, assign_block_sizes);
} }
pub fn build_display_list_for_subtree(root: &mut FlowRef, pub fn build_display_list_for_subtree(flow_root: &mut Flow,
root_stacking_context: &mut StackingContext, root_stacking_context: &mut StackingContext,
shared_layout_context: &SharedLayoutContext) shared_layout_context: &SharedLayoutContext)
-> Vec<DisplayItem> { -> Vec<DisplayItem> {
let flow_root = flow_ref::deref_mut(root);
flow_root.traverse_preorder(&ComputeAbsolutePositions { layout_context: shared_layout_context }); flow_root.traverse_preorder(&ComputeAbsolutePositions { layout_context: shared_layout_context });
let mut children = vec![]; let mut children = vec![];
flow_root.collect_stacking_contexts(root_stacking_context.id, flow_root.collect_stacking_contexts(root_stacking_context.id,
@ -89,13 +85,13 @@ pub fn build_display_list_for_subtree(root: &mut FlowRef,
root_stacking_context.add_children(children); root_stacking_context.add_children(children);
let mut build_display_list = BuildDisplayList { let mut build_display_list = BuildDisplayList {
state: DisplayListBuildState::new(shared_layout_context, state: DisplayListBuildState::new(shared_layout_context,
flow::base(&*flow_root).stacking_context_id), flow::base(flow_root).stacking_context_id),
}; };
build_display_list.traverse(&mut *flow_root); build_display_list.traverse(flow_root);
build_display_list.state.items build_display_list.state.items
} }
pub fn iterate_through_flow_tree_fragment_border_boxes(root: &mut FlowRef, pub fn iterate_through_flow_tree_fragment_border_boxes(root: &mut Flow,
iterator: &mut FragmentBorderBoxIterator) { iterator: &mut FragmentBorderBoxIterator) {
fn doit(flow: &mut Flow, fn doit(flow: &mut Flow,
level: i32, level: i32,
@ -117,7 +113,7 @@ pub fn iterate_through_flow_tree_fragment_border_boxes(root: &mut FlowRef,
} }
} }
doit(flow_ref::deref_mut(root), 0, iterator, &Point2D::zero()); doit(root, 0, iterator, &Point2D::zero());
} }
pub fn store_overflow(layout_context: &LayoutContext, flow: &mut Flow) { pub fn store_overflow(layout_context: &LayoutContext, flow: &mut Flow) {

49
components/layout_thread/lib.rs
View file

@ -872,7 +872,7 @@ impl LayoutThread {
/// This corresponds to `Reflow()` in Gecko and `layout()` in WebKit/Blink and should be /// This corresponds to `Reflow()` in Gecko and `layout()` in WebKit/Blink and should be
/// benchmarked against those two. It is marked `#[inline(never)]` to aid profiling. /// benchmarked against those two. It is marked `#[inline(never)]` to aid profiling.
#[inline(never)] #[inline(never)]
fn solve_constraints(layout_root: &mut FlowRef, fn solve_constraints(layout_root: &mut Flow,
shared_layout_context: &SharedLayoutContext) { shared_layout_context: &SharedLayoutContext) {
let _scope = layout_debug_scope!("solve_constraints"); let _scope = layout_debug_scope!("solve_constraints");
sequential::traverse_flow_tree_preorder(layout_root, shared_layout_context); sequential::traverse_flow_tree_preorder(layout_root, shared_layout_context);
@ -884,7 +884,7 @@ impl LayoutThread {
/// benchmarked against those two. It is marked `#[inline(never)]` to aid profiling. /// benchmarked against those two. It is marked `#[inline(never)]` to aid profiling.
#[inline(never)] #[inline(never)]
fn solve_constraints_parallel(traversal: &mut WorkQueue<SharedLayoutContext, WorkQueueData>, fn solve_constraints_parallel(traversal: &mut WorkQueue<SharedLayoutContext, WorkQueueData>,
layout_root: &mut FlowRef, layout_root: &mut Flow,
profiler_metadata: Option<TimerMetadata>, profiler_metadata: Option<TimerMetadata>,
time_profiler_chan: time::ProfilerChan, time_profiler_chan: time::ProfilerChan,
shared_layout_context: &SharedLayoutContext) { shared_layout_context: &SharedLayoutContext) {
@ -901,23 +901,23 @@ impl LayoutThread {
fn compute_abs_pos_and_build_display_list(&mut self, fn compute_abs_pos_and_build_display_list(&mut self,
data: &Reflow, data: &Reflow,
layout_root: &mut FlowRef, layout_root: &mut Flow,
shared_layout_context: &mut SharedLayoutContext, shared_layout_context: &mut SharedLayoutContext,
rw_data: &mut LayoutThreadData) { rw_data: &mut LayoutThreadData) {
let writing_mode = flow::base(&**layout_root).writing_mode; let writing_mode = flow::base(layout_root).writing_mode;
let (metadata, sender) = (self.profiler_metadata(), self.time_profiler_chan.clone()); let (metadata, sender) = (self.profiler_metadata(), self.time_profiler_chan.clone());
profile(time::ProfilerCategory::LayoutDispListBuild, profile(time::ProfilerCategory::LayoutDispListBuild,
metadata.clone(), metadata.clone(),
sender.clone(), sender.clone(),
|| { || {
flow::mut_base(flow_ref::deref_mut(layout_root)).stacking_relative_position = flow::mut_base(layout_root).stacking_relative_position =
LogicalPoint::zero(writing_mode).to_physical(writing_mode, LogicalPoint::zero(writing_mode).to_physical(writing_mode,
self.viewport_size); self.viewport_size);
flow::mut_base(flow_ref::deref_mut(layout_root)).clip = flow::mut_base(layout_root).clip =
ClippingRegion::from_rect(&data.page_clip_rect); ClippingRegion::from_rect(&data.page_clip_rect);
if flow::base(&**layout_root).restyle_damage.contains(REPAINT) || if flow::base(layout_root).restyle_damage.contains(REPAINT) ||
rw_data.display_list.is_none() { rw_data.display_list.is_none() {
let mut root_stacking_context = StackingContext::new(StackingContextId::new(0), let mut root_stacking_context = StackingContext::new(StackingContextId::new(0),
StackingContextType::Real, StackingContextType::Real,
@ -939,10 +939,9 @@ impl LayoutThread {
debug!("Done building display list."); debug!("Done building display list.");
let root_background_color = get_root_flow_background_color( let root_background_color = get_root_flow_background_color(layout_root);
flow_ref::deref_mut(layout_root));
let root_size = { let root_size = {
let root_flow = flow::base(&**layout_root); let root_flow = flow::base(layout_root);
if rw_data.stylist.viewport_constraints().is_some() { if rw_data.stylist.viewport_constraints().is_some() {
root_flow.position.size.to_physical(root_flow.writing_mode) root_flow.position.size.to_physical(root_flow.writing_mode)
} else { } else {
@ -992,8 +991,7 @@ impl LayoutThread {
epoch, epoch,
Some(root_scroll_layer_id), Some(root_scroll_layer_id),
&mut frame_builder); &mut frame_builder);
let root_background_color = get_root_flow_background_color( let root_background_color = get_root_flow_background_color(layout_root);
flow_ref::deref_mut(layout_root));
let root_background_color = let root_background_color =
webrender_traits::ColorF::new(root_background_color.r, webrender_traits::ColorF::new(root_background_color.r,
root_background_color.g, root_background_color.g,
@ -1211,14 +1209,15 @@ impl LayoutThread {
&mut shared_layout_context); &mut shared_layout_context);
if let Some(mut root_flow) = self.root_flow.clone() { if let Some(mut root_flow) = self.root_flow.clone() {
let root_flow = flow_ref::deref_mut(&mut root_flow);
match data.query_type { match data.query_type {
ReflowQueryType::ContentBoxQuery(node) => { ReflowQueryType::ContentBoxQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.content_box_response = process_content_box_request(node, &mut root_flow); rw_data.content_box_response = process_content_box_request(node, root_flow);
}, },
ReflowQueryType::ContentBoxesQuery(node) => { ReflowQueryType::ContentBoxesQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.content_boxes_response = process_content_boxes_request(node, &mut root_flow); rw_data.content_boxes_response = process_content_boxes_request(node, root_flow);
}, },
ReflowQueryType::HitTestQuery(translated_point, client_point, update_cursor) => { ReflowQueryType::HitTestQuery(translated_point, client_point, update_cursor) => {
let translated_point = let translated_point =
@ -1239,11 +1238,11 @@ impl LayoutThread {
}, },
ReflowQueryType::NodeGeometryQuery(node) => { ReflowQueryType::NodeGeometryQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.client_rect_response = process_node_geometry_request(node, &mut root_flow); rw_data.client_rect_response = process_node_geometry_request(node, root_flow);
}, },
ReflowQueryType::NodeScrollGeometryQuery(node) => { ReflowQueryType::NodeScrollGeometryQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.scroll_area_response = process_node_scroll_area_request(node, &mut root_flow); rw_data.scroll_area_response = process_node_scroll_area_request(node, root_flow);
}, },
ReflowQueryType::NodeOverflowQuery(node) => { ReflowQueryType::NodeOverflowQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
@ -1261,11 +1260,11 @@ impl LayoutThread {
&layout_context, &layout_context,
pseudo, pseudo,
property, property,
&mut root_flow); root_flow);
}, },
ReflowQueryType::OffsetParentQuery(node) => { ReflowQueryType::OffsetParentQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.offset_parent_response = process_offset_parent_query(node, &mut root_flow); rw_data.offset_parent_response = process_offset_parent_query(node, root_flow);
}, },
ReflowQueryType::MarginStyleQuery(node) => { ReflowQueryType::MarginStyleQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
@ -1446,7 +1445,7 @@ impl LayoutThread {
profile(time::ProfilerCategory::LayoutGeneratedContent, profile(time::ProfilerCategory::LayoutGeneratedContent,
self.profiler_metadata(), self.profiler_metadata(),
self.time_profiler_chan.clone(), self.time_profiler_chan.clone(),
|| sequential::resolve_generated_content(&mut root_flow, &layout_context)); || sequential::resolve_generated_content(flow_ref::deref_mut(&mut root_flow), &layout_context));
// Guess float placement. // Guess float placement.
profile(time::ProfilerCategory::LayoutFloatPlacementSpeculation, profile(time::ProfilerCategory::LayoutFloatPlacementSpeculation,
@ -1465,15 +1464,15 @@ impl LayoutThread {
match self.parallel_traversal { match self.parallel_traversal {
None => { None => {
// Sequential mode. // Sequential mode.
LayoutThread::solve_constraints(&mut root_flow, &layout_context) LayoutThread::solve_constraints(flow_ref::deref_mut(&mut root_flow), &layout_context)
} }
Some(ref mut parallel) => { Some(ref mut parallel) => {
// Parallel mode. // Parallel mode.
LayoutThread::solve_constraints_parallel(parallel, LayoutThread::solve_constraints_parallel(parallel,
&mut root_flow, flow_ref::deref_mut(&mut root_flow),
profiler_metadata, profiler_metadata,
self.time_profiler_chan.clone(), self.time_profiler_chan.clone(),
&*layout_context); &*layout_context);
} }
} }
}); });
@ -1499,7 +1498,7 @@ impl LayoutThread {
// Build the display list if necessary, and send it to the painter. // Build the display list if necessary, and send it to the painter.
if let Some(mut root_flow) = self.root_flow.clone() { if let Some(mut root_flow) = self.root_flow.clone() {
self.compute_abs_pos_and_build_display_list(data, self.compute_abs_pos_and_build_display_list(data,
&mut root_flow, flow_ref::deref_mut(&mut root_flow),
&mut *layout_context, &mut *layout_context,
rw_data); rw_data);
self.first_reflow = false; self.first_reflow = false;