diff options
Diffstat (limited to 'components/layout')
| -rw-r--r-- | components/layout/animation.rs | 6 | ||||
| -rw-r--r-- | components/layout/block.rs | 21 | ||||
| -rw-r--r-- | components/layout/context.rs | 78 | ||||
| -rw-r--r-- | components/layout/css/matching.rs | 351 | ||||
| -rw-r--r-- | components/layout/layout_task.rs | 23 | ||||
| -rw-r--r-- | components/layout/traversal.rs | 16 |
6 files changed, 74 insertions, 421 deletions
diff --git a/components/layout/animation.rs b/components/layout/animation.rs index 9160c317a5a..4a8932ad2e8 100644 --- a/components/layout/animation.rs +++ b/components/layout/animation.rs @@ -40,7 +40,7 @@ pub fn start_transitions_if_applicable(new_animations_sender: &Mutex<Sender<Anim let start_time = now + (animation_style.transition_delay.0.get_mod(i).seconds() as f64); new_animations_sender.lock().unwrap().send(Animation { - node: node.id(), + node: node, property_animation: property_animation, start_time: start_time, end_time: start_time + @@ -101,7 +101,7 @@ pub fn update_animation_state(constellation_chan: &ConstellationChan<Constellati // Add new running animations. for new_running_animation in new_running_animations { - match running_animations.entry(OpaqueNode(new_running_animation.node)) { + match running_animations.entry(new_running_animation.node) { Entry::Vacant(entry) => { entry.insert(vec![new_running_animation]); } @@ -126,7 +126,7 @@ pub fn recalc_style_for_animations(flow: &mut Flow, animations: &HashMap<OpaqueNode, Vec<Animation>>) { let mut damage = RestyleDamage::empty(); flow.mutate_fragments(&mut |fragment| { - if let Some(ref animations) = animations.get(&OpaqueNode(fragment.node.id())) { + if let Some(ref animations) = animations.get(&fragment.node) { for animation in *animations { update_style_for_animation(animation, &mut fragment.style, Some(&mut damage)); } diff --git a/components/layout/block.rs b/components/layout/block.rs index ebda80f4035..5b34977b484 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -56,6 +56,7 @@ use std::fmt; use std::sync::Arc; use style::computed_values::{border_collapse, box_sizing, display, float, overflow_x, overflow_y}; use style::computed_values::{position, text_align, transform_style}; +use style::context::StyleContext; use style::properties::ComputedValues; use style::values::computed::{LengthOrNone, LengthOrPercentageOrNone}; use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto}; @@ -890,7 +891,7 @@ impl BlockFlow { if is_root { let viewport_size = LogicalSize::from_physical(self.fragment.style.writing_mode, - layout_context.shared.viewport_size); + layout_context.shared_context().viewport_size); block_size = max(viewport_size.block, block_size) } @@ -1051,7 +1052,7 @@ impl BlockFlow { pub fn explicit_block_containing_size(&self, layout_context: &LayoutContext) -> Option<Au> { if self.is_root() || self.is_fixed() { let viewport_size = LogicalSize::from_physical(self.fragment.style.writing_mode, - layout_context.shared.viewport_size); + layout_context.shared_context().viewport_size); Some(viewport_size.block) } else if self.base.flags.contains(IS_ABSOLUTELY_POSITIONED) && self.base.block_container_explicit_block_size.is_none() { @@ -1117,7 +1118,7 @@ impl BlockFlow { fn calculate_absolute_block_size_and_margins(&mut self, layout_context: &LayoutContext) { let opaque_self = OpaqueFlow::from_flow(self); let containing_block_block_size = - self.containing_block_size(&layout_context.shared.viewport_size, opaque_self).block; + self.containing_block_size(&layout_context.shared_context().viewport_size, opaque_self).block; // This is the stored content block-size value from assign-block-size let content_block_size = self.fragment.border_box.size.block; @@ -1270,7 +1271,7 @@ impl BlockFlow { // Calculate containing block inline size. let containing_block_size = if flags.contains(IS_ABSOLUTELY_POSITIONED) { - self.containing_block_size(&layout_context.shared.viewport_size, opaque_self).inline + self.containing_block_size(&layout_context.shared_context().viewport_size, opaque_self).inline } else { content_inline_size }; @@ -1603,7 +1604,7 @@ impl Flow for BlockFlow { debug!("Setting root position"); self.base.position.start = LogicalPoint::zero(self.base.writing_mode); self.base.block_container_inline_size = LogicalSize::from_physical( - self.base.writing_mode, layout_context.shared.viewport_size).inline; + self.base.writing_mode, layout_context.shared_context().viewport_size).inline; self.base.block_container_writing_mode = self.base.writing_mode; // The root element is never impacted by floats. @@ -1862,10 +1863,10 @@ impl Flow for BlockFlow { let visible_rect = match layout_context.shared.visible_rects.get(&self.layer_id()) { Some(visible_rect) => *visible_rect, - None => Rect::new(Point2D::zero(), layout_context.shared.viewport_size), + None => Rect::new(Point2D::zero(), layout_context.shared_context().viewport_size), }; - let viewport_size = layout_context.shared.viewport_size; + let viewport_size = layout_context.shared_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 { @@ -2591,7 +2592,7 @@ impl ISizeAndMarginsComputer for AbsoluteNonReplaced { layout_context: &LayoutContext) -> Au { let opaque_block = OpaqueFlow::from_flow(block); - block.containing_block_size(&layout_context.shared.viewport_size, opaque_block).inline + block.containing_block_size(&layout_context.shared_context().viewport_size, opaque_block).inline } fn set_inline_position_of_flow_if_necessary(&self, @@ -2703,7 +2704,7 @@ impl ISizeAndMarginsComputer for AbsoluteReplaced { -> MaybeAuto { let opaque_block = OpaqueFlow::from_flow(block); let containing_block_inline_size = - block.containing_block_size(&layout_context.shared.viewport_size, opaque_block).inline; + block.containing_block_size(&layout_context.shared_context().viewport_size, opaque_block).inline; let fragment = block.fragment(); fragment.assign_replaced_inline_size_if_necessary(containing_block_inline_size); // For replaced absolute flow, the rest of the constraint solving will @@ -2717,7 +2718,7 @@ impl ISizeAndMarginsComputer for AbsoluteReplaced { layout_context: &LayoutContext) -> Au { let opaque_block = OpaqueFlow::from_flow(block); - block.containing_block_size(&layout_context.shared.viewport_size, opaque_block).inline + block.containing_block_size(&layout_context.shared_context().viewport_size, opaque_block).inline } fn set_inline_position_of_flow_if_necessary(&self, diff --git a/components/layout/context.rs b/components/layout/context.rs index 16ca36043ad..a10fe334730 100644 --- a/components/layout/context.rs +++ b/components/layout/context.rs @@ -8,34 +8,30 @@ use app_units::Au; use canvas_traits::CanvasMsg; -use css::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache}; -use euclid::{Rect, Size2D}; +use euclid::Rect; use fnv::FnvHasher; -use gfx::display_list::OpaqueNode; use gfx::font_cache_task::FontCacheTask; use gfx::font_context::FontContext; use gfx_traits::LayerId; use ipc_channel::ipc::{self, IpcSender}; -use msg::ParseErrorReporter; use net_traits::image::base::Image; use net_traits::image_cache_task::{ImageCacheChan, ImageCacheTask, ImageResponse, ImageState}; use net_traits::image_cache_task::{UsePlaceholder}; -use script::layout_interface::{Animation, ReflowGoal}; use std::cell::{RefCell, RefMut}; use std::collections::HashMap; use std::collections::hash_state::DefaultState; use std::rc::Rc; use std::sync::mpsc::{Sender, channel}; -use std::sync::{Arc, Mutex, RwLock}; -use style::selector_matching::Stylist; +use std::sync::{Arc, Mutex}; +use style::context::{LocalStyleContext, SharedStyleContext, StyleContext}; +use style::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache}; use url::Url; use util::mem::HeapSizeOf; use util::opts; struct LocalLayoutContext { + style_context: LocalStyleContext, font_context: RefCell<FontContext>, - applicable_declarations_cache: RefCell<ApplicableDeclarationsCache>, - style_sharing_candidate_cache: RefCell<StyleSharingCandidateCache>, } impl HeapSizeOf for LocalLayoutContext { @@ -58,16 +54,18 @@ fn create_or_get_local_context(shared_layout_context: &SharedLayoutContext) LOCAL_CONTEXT_KEY.with(|r| { let mut r = r.borrow_mut(); if let Some(context) = r.clone() { - if shared_layout_context.screen_size_changed { - context.applicable_declarations_cache.borrow_mut().evict_all(); + if shared_layout_context.style_context.screen_size_changed { + context.style_context.applicable_declarations_cache.borrow_mut().evict_all(); } context } else { let font_cache_task = shared_layout_context.font_cache_task.lock().unwrap().clone(); let context = Rc::new(LocalLayoutContext { + style_context: LocalStyleContext { + applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()), + style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()), + }, font_context: RefCell::new(FontContext::new(font_cache_task)), - applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()), - style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()), }); *r = Some(context.clone()); context @@ -75,62 +73,28 @@ fn create_or_get_local_context(shared_layout_context: &SharedLayoutContext) }) } -pub struct StylistWrapper(pub *const Stylist); - -// FIXME(#6569) This implementation is unsound. -#[allow(unsafe_code)] -unsafe impl Sync for StylistWrapper {} - /// Layout information shared among all workers. This must be thread-safe. pub struct SharedLayoutContext { + /// Bits shared by the layout and style system. + pub style_context: SharedStyleContext, + /// The shared image cache task. pub image_cache_task: ImageCacheTask, /// A channel for the image cache to send responses to. pub image_cache_sender: Mutex<ImageCacheChan>, - /// The current viewport size. - pub viewport_size: Size2D<Au>, - - /// Screen sized changed? - pub screen_size_changed: bool, - /// Interface to the font cache task. pub font_cache_task: Mutex<FontCacheTask>, - /// The CSS selector stylist. - /// - /// FIXME(#2604): Make this no longer an unsafe pointer once we have fast `RWArc`s. - pub stylist: StylistWrapper, - /// The URL. pub url: Url, - /// Starts at zero, and increased by one every time a layout completes. - /// This can be used to easily check for invalid stale data. - pub generation: u32, - - /// A channel on which new animations that have been triggered by style recalculation can be - /// sent. - pub new_animations_sender: Mutex<Sender<Animation>>, - /// A channel to send canvas renderers to paint task, in order to correctly paint the layers pub canvas_layers_sender: Mutex<Sender<(LayerId, IpcSender<CanvasMsg>)>>, /// The visible rects for each layer, as reported to us by the compositor. pub visible_rects: Arc<HashMap<LayerId, Rect<Au>, DefaultState<FnvHasher>>>, - - /// The animations that are currently running. - pub running_animations: Arc<RwLock<HashMap<OpaqueNode, Vec<Animation>>>>, - - /// The list of animations that have expired since the last style recalculation. - pub expired_animations: Arc<RwLock<HashMap<OpaqueNode, Vec<Animation>>>>, - - /// Why is this reflow occurring - pub goal: ReflowGoal, - - ///The CSS error reporter for all CSS loaded in this layout thread - pub error_reporter: Box<ParseErrorReporter + Sync> } pub struct LayoutContext<'a> { @@ -138,6 +102,16 @@ pub struct LayoutContext<'a> { cached_local_layout_context: Rc<LocalLayoutContext>, } +impl<'a> StyleContext<'a> for LayoutContext<'a> { + fn shared_context(&self) -> &'a SharedStyleContext { + &self.shared.style_context + } + + fn local_context(&self) -> &LocalStyleContext { + &self.cached_local_layout_context.style_context + } +} + impl<'a> LayoutContext<'a> { pub fn new(shared_layout_context: &'a SharedLayoutContext) -> LayoutContext<'a> { @@ -156,12 +130,12 @@ impl<'a> LayoutContext<'a> { #[inline(always)] pub fn applicable_declarations_cache(&self) -> RefMut<ApplicableDeclarationsCache> { - self.cached_local_layout_context.applicable_declarations_cache.borrow_mut() + self.local_context().applicable_declarations_cache.borrow_mut() } #[inline(always)] pub fn style_sharing_candidate_cache(&self) -> RefMut<StyleSharingCandidateCache> { - self.cached_local_layout_context.style_sharing_candidate_cache.borrow_mut() + self.local_context().style_sharing_candidate_cache.borrow_mut() } pub fn get_or_request_image(&self, url: Url, use_placeholder: UsePlaceholder) diff --git a/components/layout/css/matching.rs b/components/layout/css/matching.rs index a9c07848309..e83899e2893 100644 --- a/components/layout/css/matching.rs +++ b/components/layout/css/matching.rs @@ -13,347 +13,19 @@ use incremental::{self, RestyleDamage}; use msg::ParseErrorReporter; use script::layout_interface::Animation; use selectors::bloom::BloomFilter; -use selectors::matching::{CommonStyleAffectingAttributeMode, CommonStyleAffectingAttributes}; -use selectors::matching::{common_style_affecting_attributes, rare_style_affecting_attributes}; use selectors::parser::PseudoElement; use selectors::{Element}; -use smallvec::SmallVec; -use std::borrow::ToOwned; -use std::hash::{Hash, Hasher}; use std::mem::transmute; -use std::slice::Iter; use std::sync::mpsc::Sender; use std::sync::{Arc, Mutex}; -use string_cache::{Atom, Namespace}; use style::data::PrivateStyleData; use style::dom::{TElement, TNode}; -use style::properties::{ComputedValues, PropertyDeclaration, cascade}; +use style::matching::{ApplicableDeclarations, ApplicableDeclarationsCache}; +use style::matching::{StyleSharingCandidate, StyleSharingCandidateCache}; +use style::properties::{ComputedValues, cascade}; use style::selector_matching::{DeclarationBlock, Stylist}; use util::arc_ptr_eq; -use util::cache::{LRUCache, SimpleHashCache}; use util::opts; -use util::vec::ForgetfulSink; - -pub struct ApplicableDeclarations { - pub normal: SmallVec<[DeclarationBlock; 16]>, - pub before: Vec<DeclarationBlock>, - pub after: Vec<DeclarationBlock>, - - /// Whether the `normal` declarations are shareable with other nodes. - pub normal_shareable: bool, -} - -impl ApplicableDeclarations { - pub fn new() -> ApplicableDeclarations { - ApplicableDeclarations { - normal: SmallVec::new(), - before: Vec::new(), - after: Vec::new(), - normal_shareable: false, - } - } -} - -#[derive(Clone)] -pub struct ApplicableDeclarationsCacheEntry { - pub declarations: Vec<DeclarationBlock>, -} - -impl ApplicableDeclarationsCacheEntry { - fn new(declarations: Vec<DeclarationBlock>) -> ApplicableDeclarationsCacheEntry { - ApplicableDeclarationsCacheEntry { - declarations: declarations, - } - } -} - -impl PartialEq for ApplicableDeclarationsCacheEntry { - fn eq(&self, other: &ApplicableDeclarationsCacheEntry) -> bool { - let this_as_query = ApplicableDeclarationsCacheQuery::new(&*self.declarations); - this_as_query.eq(other) - } -} -impl Eq for ApplicableDeclarationsCacheEntry {} - -impl Hash for ApplicableDeclarationsCacheEntry { - fn hash<H: Hasher>(&self, state: &mut H) { - let tmp = ApplicableDeclarationsCacheQuery::new(&*self.declarations); - tmp.hash(state); - } -} - -struct ApplicableDeclarationsCacheQuery<'a> { - declarations: &'a [DeclarationBlock], -} - -impl<'a> ApplicableDeclarationsCacheQuery<'a> { - fn new(declarations: &'a [DeclarationBlock]) -> ApplicableDeclarationsCacheQuery<'a> { - ApplicableDeclarationsCacheQuery { - declarations: declarations, - } - } -} - -impl<'a> PartialEq for ApplicableDeclarationsCacheQuery<'a> { - fn eq(&self, other: &ApplicableDeclarationsCacheQuery<'a>) -> bool { - if self.declarations.len() != other.declarations.len() { - return false - } - for (this, other) in self.declarations.iter().zip(other.declarations) { - if !arc_ptr_eq(&this.declarations, &other.declarations) { - return false - } - } - true - } -} -impl<'a> Eq for ApplicableDeclarationsCacheQuery<'a> {} - -impl<'a> PartialEq<ApplicableDeclarationsCacheEntry> for ApplicableDeclarationsCacheQuery<'a> { - fn eq(&self, other: &ApplicableDeclarationsCacheEntry) -> bool { - let other_as_query = ApplicableDeclarationsCacheQuery::new(&other.declarations); - self.eq(&other_as_query) - } -} - -impl<'a> Hash for ApplicableDeclarationsCacheQuery<'a> { - fn hash<H: Hasher>(&self, state: &mut H) { - for declaration in self.declarations { - // Each declaration contians an Arc, which is a stable - // pointer; we use that for hashing and equality. - let ptr = &*declaration.declarations as *const Vec<PropertyDeclaration>; - ptr.hash(state); - } - } -} - -static APPLICABLE_DECLARATIONS_CACHE_SIZE: usize = 32; - -pub struct ApplicableDeclarationsCache { - cache: SimpleHashCache<ApplicableDeclarationsCacheEntry, Arc<ComputedValues>>, -} - -impl ApplicableDeclarationsCache { - pub fn new() -> ApplicableDeclarationsCache { - ApplicableDeclarationsCache { - cache: SimpleHashCache::new(APPLICABLE_DECLARATIONS_CACHE_SIZE), - } - } - - fn find(&self, declarations: &[DeclarationBlock]) -> Option<Arc<ComputedValues>> { - match self.cache.find(&ApplicableDeclarationsCacheQuery::new(declarations)) { - None => None, - Some(ref values) => Some((*values).clone()), - } - } - - fn insert(&mut self, declarations: Vec<DeclarationBlock>, style: Arc<ComputedValues>) { - self.cache.insert(ApplicableDeclarationsCacheEntry::new(declarations), style) - } - - pub fn evict_all(&mut self) { - self.cache.evict_all(); - } -} - -/// An LRU cache of the last few nodes seen, so that we can aggressively try to reuse their styles. -pub struct StyleSharingCandidateCache { - cache: LRUCache<StyleSharingCandidate, ()>, -} - -fn create_common_style_affecting_attributes_from_element<'le, E: TElement<'le>>(element: &E) - -> CommonStyleAffectingAttributes { - let mut flags = CommonStyleAffectingAttributes::empty(); - for attribute_info in &common_style_affecting_attributes() { - match attribute_info.mode { - CommonStyleAffectingAttributeMode::IsPresent(flag) => { - if element.get_attr(&ns!(), &attribute_info.atom).is_some() { - flags.insert(flag) - } - } - CommonStyleAffectingAttributeMode::IsEqual(target_value, flag) => { - match element.get_attr(&ns!(), &attribute_info.atom) { - Some(element_value) if element_value == target_value => { - flags.insert(flag) - } - _ => {} - } - } - } - } - flags -} - -#[derive(Clone)] -pub struct StyleSharingCandidate { - pub style: Arc<ComputedValues>, - pub parent_style: Arc<ComputedValues>, - pub local_name: Atom, - // FIXME(pcwalton): Should be a list of atoms instead. - pub class: Option<String>, - pub namespace: Namespace, - pub common_style_affecting_attributes: CommonStyleAffectingAttributes, - pub link: bool, -} - -impl PartialEq for StyleSharingCandidate { - fn eq(&self, other: &StyleSharingCandidate) -> bool { - arc_ptr_eq(&self.style, &other.style) && - arc_ptr_eq(&self.parent_style, &other.parent_style) && - self.local_name == other.local_name && - self.class == other.class && - self.link == other.link && - self.namespace == other.namespace && - self.common_style_affecting_attributes == other.common_style_affecting_attributes - } -} - -impl StyleSharingCandidate { - /// Attempts to create a style sharing candidate from this node. Returns - /// the style sharing candidate or `None` if this node is ineligible for - /// style sharing. - fn new<'le, E: TElement<'le>>(element: &E) -> Option<StyleSharingCandidate> { - let parent_element = match element.parent_element() { - None => return None, - Some(parent_element) => parent_element, - }; - - let style = unsafe { - match element.as_node().borrow_data_unchecked() { - None => return None, - Some(data_ref) => { - match (*data_ref).style { - None => return None, - Some(ref data) => (*data).clone(), - } - } - } - }; - let parent_style = unsafe { - match parent_element.as_node().borrow_data_unchecked() { - None => return None, - Some(parent_data_ref) => { - match (*parent_data_ref).style { - None => return None, - Some(ref data) => (*data).clone(), - } - } - } - }; - - if element.style_attribute().is_some() { - return None - } - - Some(StyleSharingCandidate { - style: style, - parent_style: parent_style, - local_name: element.get_local_name().clone(), - class: element.get_attr(&ns!(), &atom!("class")) - .map(|string| string.to_owned()), - link: element.is_link(), - namespace: (*element.get_namespace()).clone(), - common_style_affecting_attributes: - create_common_style_affecting_attributes_from_element::<'le, E>(&element) - }) - } - - fn can_share_style_with<'a, E: TElement<'a>>(&self, element: &E) -> bool { - if *element.get_local_name() != self.local_name { - return false - } - - // FIXME(pcwalton): Use `each_class` here instead of slow string comparison. - match (&self.class, element.get_attr(&ns!(), &atom!("class"))) { - (&None, Some(_)) | (&Some(_), None) => return false, - (&Some(ref this_class), Some(element_class)) if - element_class != &**this_class => { - return false - } - (&Some(_), Some(_)) | (&None, None) => {} - } - - if *element.get_namespace() != self.namespace { - return false - } - - let mut matching_rules = ForgetfulSink::new(); - element.synthesize_presentational_hints_for_legacy_attributes(&mut matching_rules); - if !matching_rules.is_empty() { - return false; - } - - // FIXME(pcwalton): It's probably faster to iterate over all the element's attributes and - // use the {common, rare}-style-affecting-attributes tables as lookup tables. - - for attribute_info in &common_style_affecting_attributes() { - match attribute_info.mode { - CommonStyleAffectingAttributeMode::IsPresent(flag) => { - if self.common_style_affecting_attributes.contains(flag) != - element.get_attr(&ns!(), &attribute_info.atom).is_some() { - return false - } - } - CommonStyleAffectingAttributeMode::IsEqual(target_value, flag) => { - match element.get_attr(&ns!(), &attribute_info.atom) { - Some(ref element_value) if self.common_style_affecting_attributes - .contains(flag) && - *element_value != target_value => { - return false - } - Some(_) if !self.common_style_affecting_attributes.contains(flag) => { - return false - } - None if self.common_style_affecting_attributes.contains(flag) => { - return false - } - _ => {} - } - } - } - } - - for attribute_name in &rare_style_affecting_attributes() { - if element.get_attr(&ns!(), attribute_name).is_some() { - return false - } - } - - if element.is_link() != self.link { - return false - } - - // TODO(pcwalton): We don't support visited links yet, but when we do there will need to - // be some logic here. - - true - } -} - -static STYLE_SHARING_CANDIDATE_CACHE_SIZE: usize = 40; - -impl StyleSharingCandidateCache { - pub fn new() -> StyleSharingCandidateCache { - StyleSharingCandidateCache { - cache: LRUCache::new(STYLE_SHARING_CANDIDATE_CACHE_SIZE), - } - } - - pub fn iter(&self) -> Iter<(StyleSharingCandidate, ())> { - self.cache.iter() - } - - pub fn insert_if_possible<'le, E: TElement<'le>>(&mut self, element: &E) { - match StyleSharingCandidate::new(element) { - None => {} - Some(candidate) => self.cache.insert(candidate, ()) - } - } - - pub fn touch(&mut self, index: usize) { - self.cache.touch(index) - } -} /// The results of attempting to share a style. pub enum StyleSharingResult { @@ -454,22 +126,22 @@ impl<'ln, ConcreteNode> PrivateMatchMethods for ConcreteNode None => None, Some(ref style) => Some(&**style), }; - let (the_style, is_cacheable) = cascade(layout_context.viewport_size, + let (the_style, is_cacheable) = cascade(layout_context.style_context.viewport_size, applicable_declarations, shareable, Some(&***parent_style), cached_computed_values, - layout_context.error_reporter.clone()); + layout_context.style_context.error_reporter.clone()); cacheable = cacheable && is_cacheable; this_style = the_style } None => { - let (the_style, is_cacheable) = cascade(layout_context.viewport_size, + let (the_style, is_cacheable) = cascade(layout_context.style_context.viewport_size, applicable_declarations, shareable, None, None, - layout_context.error_reporter.clone()); + layout_context.style_context.error_reporter.clone()); cacheable = cacheable && is_cacheable; this_style = the_style } @@ -516,7 +188,7 @@ impl<'ln, ConcreteNode> PrivateMatchMethods for ConcreteNode let this_opaque = self.opaque(); let had_animations_to_expire; { - let all_expired_animations = layout_context.expired_animations.read().unwrap(); + let all_expired_animations = layout_context.style_context.expired_animations.read().unwrap(); let animations_to_expire = all_expired_animations.get(&this_opaque); had_animations_to_expire = animations_to_expire.is_some(); if let Some(ref animations) = animations_to_expire { @@ -527,17 +199,18 @@ impl<'ln, ConcreteNode> PrivateMatchMethods for ConcreteNode } if had_animations_to_expire { - layout_context.expired_animations.write().unwrap().remove(&this_opaque); + layout_context.style_context.expired_animations.write().unwrap().remove(&this_opaque); } // Merge any running transitions into the current style, and cancel them. - let had_running_animations = layout_context.running_animations + let had_running_animations = layout_context.style_context + .running_animations .read() .unwrap() .get(&this_opaque) .is_some(); if had_running_animations { - let mut all_running_animations = layout_context.running_animations.write().unwrap(); + let mut all_running_animations = layout_context.style_context.running_animations.write().unwrap(); for running_animation in all_running_animations.get(&this_opaque).unwrap() { animation::update_style_for_animation(running_animation, style, None); } diff --git a/components/layout/layout_task.rs b/components/layout/layout_task.rs index 64bf9f1329c..87f34ce2a8c 100644 --- a/components/layout/layout_task.rs +++ b/components/layout/layout_task.rs @@ -12,7 +12,7 @@ use app_units::Au; use azure::azure::AzColor; use canvas_traits::CanvasMsg; use construct::ConstructionResult; -use context::{SharedLayoutContext, StylistWrapper, heap_size_of_local_context}; +use context::{SharedLayoutContext, heap_size_of_local_context}; use display_list_builder::ToGfxColor; use euclid::Matrix4; use euclid::point::Point2D; @@ -64,6 +64,7 @@ use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::{Arc, Mutex, MutexGuard, RwLock}; use style::computed_values::{filter, mix_blend_mode}; +use style::context::{SharedStyleContext, StylistWrapper}; use style::dom::{TDocument, TElement, TNode}; use style::media_queries::{Device, MediaType}; use style::selector_matching::{Stylist, USER_OR_USER_AGENT_STYLESHEETS}; @@ -470,21 +471,23 @@ impl LayoutTask { goal: ReflowGoal) -> SharedLayoutContext { SharedLayoutContext { + style_context: SharedStyleContext { + viewport_size: self.viewport_size.clone(), + screen_size_changed: screen_size_changed, + stylist: StylistWrapper(&*rw_data.stylist), + generation: self.generation, + goal: goal, + new_animations_sender: Mutex::new(self.new_animations_sender.clone()), + running_animations: self.running_animations.clone(), + expired_animations: self.expired_animations.clone(), + error_reporter: self.error_reporter.clone(), + }, image_cache_task: self.image_cache_task.clone(), image_cache_sender: Mutex::new(self.image_cache_sender.clone()), - viewport_size: self.viewport_size.clone(), - screen_size_changed: screen_size_changed, font_cache_task: Mutex::new(self.font_cache_task.clone()), canvas_layers_sender: Mutex::new(self.canvas_layers_sender.clone()), - stylist: StylistWrapper(&*rw_data.stylist), url: (*url).clone(), visible_rects: self.visible_rects.clone(), - generation: self.generation, - new_animations_sender: Mutex::new(self.new_animations_sender.clone()), - goal: goal, - running_animations: self.running_animations.clone(), - expired_animations: self.expired_animations.clone(), - error_reporter: self.error_reporter.clone(), } } diff --git a/components/layout/traversal.rs b/components/layout/traversal.rs index 007b3a3626d..c5bf7d482f3 100644 --- a/components/layout/traversal.rs +++ b/components/layout/traversal.rs @@ -6,7 +6,7 @@ use construct::FlowConstructor; use context::LayoutContext; -use css::matching::{ApplicableDeclarations, ElementMatchMethods, MatchMethods, StyleSharingResult}; +use css::matching::{ElementMatchMethods, MatchMethods, StyleSharingResult}; use flow::{PostorderFlowTraversal, PreorderFlowTraversal}; use flow::{self, Flow}; use gfx::display_list::OpaqueNode; @@ -15,7 +15,9 @@ use script::layout_interface::ReflowGoal; use selectors::bloom::BloomFilter; use std::cell::RefCell; use std::mem; +use style::context::StyleContext; use style::dom::UnsafeNode; +use style::matching::ApplicableDeclarations; use util::opts; use util::tid::tid; use wrapper::{LayoutNode, ThreadSafeLayoutNode}; @@ -72,7 +74,7 @@ fn take_task_local_bloom_filter<'ln, N>(parent_node: Option<N>, // Found cached bloom filter. (Some(parent), Some((mut bloom_filter, old_node, old_generation))) => { if old_node == parent.to_unsafe() && - old_generation == layout_context.shared.generation { + old_generation == layout_context.shared_context().generation { // Hey, the cached parent is our parent! We can reuse the bloom filter. debug!("[{}] Parent matches (={}). Reusing bloom filter.", tid(), old_node.0); } else { @@ -93,7 +95,7 @@ fn put_task_local_bloom_filter(bf: Box<BloomFilter>, STYLE_BLOOM.with(move |style_bloom| { assert!(style_bloom.borrow().is_none(), "Putting into a never-taken task-local bloom filter"); - *style_bloom.borrow_mut() = Some((bf, *unsafe_node, layout_context.shared.generation)); + *style_bloom.borrow_mut() = Some((bf, *unsafe_node, layout_context.shared_context().generation)); }) } @@ -192,7 +194,7 @@ impl<'a, 'ln, ConcreteLayoutNode> PreorderDomTraversal<'ln, ConcreteLayoutNode> let shareable_element = match node.as_element() { Some(element) => { // Perform the CSS selector matching. - let stylist = unsafe { &*self.layout_context.shared.stylist.0 }; + let stylist = unsafe { &*self.layout_context.shared_context().stylist.0 }; if element.match_element(stylist, Some(&*bf), &mut applicable_declarations) { @@ -216,7 +218,7 @@ impl<'a, 'ln, ConcreteLayoutNode> PreorderDomTraversal<'ln, ConcreteLayoutNode> parent_opt, &applicable_declarations, &mut self.layout_context.applicable_declarations_cache(), - &self.layout_context.shared.new_animations_sender); + &self.layout_context.shared_context().new_animations_sender); } // Add ourselves to the LRU cache. @@ -292,7 +294,7 @@ impl<'a, 'ln, ConcreteLayoutNode> PostorderDomTraversal<'ln, ConcreteLayoutNode> }); assert_eq!(old_node, unsafe_layout_node); - assert_eq!(old_generation, self.layout_context.shared.generation); + assert_eq!(old_generation, self.layout_context.shared_context().generation); match node.layout_parent_node(self.root) { None => { @@ -401,6 +403,6 @@ impl<'a> PostorderFlowTraversal for BuildDisplayList<'a> { #[inline] fn should_process(&self, _: &mut Flow) -> bool { - self.layout_context.shared.goal == ReflowGoal::ForDisplay + self.layout_context.shared_context().goal == ReflowGoal::ForDisplay } } |