diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs index 8aa3b2da396..a0aeaec2e5c 100644 --- a/components/style/gecko/media_queries.rs +++ b/components/style/gecko/media_queries.rs @@ -16,7 +16,7 @@ use gecko_bindings::structs::{nsMediaFeature_ValueType, nsMediaFeature_RangeType use gecko_bindings::structs::RawGeckoPresContextOwned; use media_queries::MediaType; use parser::ParserContext; -use properties::ComputedValues; +use properties::{ComputedValues, StyleBuilder}; use std::fmt::{self, Write}; use std::sync::Arc; use str::starts_with_ignore_ascii_case; @@ -552,6 +552,7 @@ impl Expression { let default_values = device.default_computed_values(); + let provider = get_metrics_provider_for_product(); // http://dev.w3.org/csswg/mediaqueries3/#units @@ -561,10 +562,9 @@ impl Expression { device: device, inherited_style: default_values, layout_parent_style: default_values, - // This cloning business is kind of dumb.... It's because Context - // insists on having an actual ComputedValues inside itself. - style: default_values.clone(), + style: StyleBuilder::for_derived_style(default_values), font_metrics_provider: &provider, + cached_system_font: None, in_media_query: true, // TODO: pass the correct value here. quirks_mode: quirks_mode, diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index b8f4d4ed541..f0fbe045c11 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -102,32 +102,13 @@ pub struct ComputedValues { } impl ComputedValues { - /// Inherits style from the parent element, accounting for the default - /// computed values that need to be provided as well. - pub fn inherit_from(parent: &Self, default: &Self) -> Self { - ComputedValues { - custom_properties: parent.custom_properties.clone(), - writing_mode: parent.writing_mode, - root_font_size: parent.root_font_size, - font_size_keyword: parent.font_size_keyword, - cached_system_font: None, - % for style_struct in data.style_structs: - % if style_struct.inherited: - ${style_struct.ident}: parent.${style_struct.ident}.clone(), - % else: - ${style_struct.ident}: default.${style_struct.ident}.clone(), - % endif - % endfor - } - } - pub fn new(custom_properties: Option>, - writing_mode: WritingMode, - root_font_size: Au, - font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, - % for style_struct in data.style_structs: - ${style_struct.ident}: Arc, - % endfor + writing_mode: WritingMode, + root_font_size: Au, + font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + % for style_struct in data.style_structs: + ${style_struct.ident}: Arc, + % endfor ) -> Self { ComputedValues { custom_properties: custom_properties, @@ -168,6 +149,11 @@ impl ComputedValues { pub fn get_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} { &self.${style_struct.ident} } + + pub fn ${style_struct.name_lower}_arc(&self) -> &Arc { + &self.${style_struct.ident} + } + #[inline] pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} { Arc::make_mut(&mut self.${style_struct.ident}) @@ -175,7 +161,7 @@ impl ComputedValues { % endfor pub fn custom_properties(&self) -> Option> { - self.custom_properties.as_ref().map(|x| x.clone()) + self.custom_properties.clone() } #[allow(non_snake_case)] @@ -183,12 +169,6 @@ impl ComputedValues { !self.get_box().gecko.mBinding.mPtr.mRawPtr.is_null() } - #[allow(non_snake_case)] - pub fn in_top_layer(&self) -> bool { - matches!(self.get_box().clone__moz_top_layer(), - longhands::_moz_top_layer::SpecifiedValue::top) - } - // FIXME(bholley): Implement this properly. #[inline] pub fn is_multicol(&self) -> bool { false } diff --git a/components/style/properties/helpers.mako.rs b/components/style/properties/helpers.mako.rs index 472bf1c0a93..4db19381e1f 100644 --- a/components/style/properties/helpers.mako.rs +++ b/components/style/properties/helpers.mako.rs @@ -478,7 +478,7 @@ SpecifiedValue::Keyword(v) => v, SpecifiedValue::System(_) => { % if product == "gecko": - _cx.style.cached_system_font.as_ref().unwrap().${to_rust_ident(name)} + _cx.cached_system_font.as_ref().unwrap().${to_rust_ident(name)} % else: unreachable!() % endif diff --git a/components/style/properties/longhand/font.mako.rs b/components/style/properties/longhand/font.mako.rs index 02df590ee9d..e99b15dd9cf 100644 --- a/components/style/properties/longhand/font.mako.rs +++ b/components/style/properties/longhand/font.mako.rs @@ -50,7 +50,7 @@ SpecifiedValue::Value(v) => v, SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - _context.style.cached_system_font.as_ref().unwrap().${name} + _context.cached_system_font.as_ref().unwrap().${name} } } @@ -270,7 +270,7 @@ SpecifiedValue::Values(ref v) => computed_value::T(v.clone()), SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - _cx.style.cached_system_font.as_ref().unwrap().font_family.clone() + _cx.cached_system_font.as_ref().unwrap().font_family.clone() } } @@ -532,7 +532,7 @@ ${helpers.single_keyword_system("font-variant-caps", }, SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - context.style.cached_system_font.as_ref().unwrap().font_weight.clone() + context.cached_system_font.as_ref().unwrap().font_weight.clone() } } @@ -809,7 +809,7 @@ ${helpers.single_keyword_system("font-variant-caps", SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - context.style.cached_system_font.as_ref().unwrap().font_size + context.cached_system_font.as_ref().unwrap().font_size } } @@ -982,7 +982,7 @@ ${helpers.single_keyword_system("font-variant-caps", SpecifiedValue::Number(ref n) => computed_value::T::Number(n.to_computed_value(context)), SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - context.style.cached_system_font.as_ref().unwrap().font_size_adjust + context.cached_system_font.as_ref().unwrap().font_size_adjust } } @@ -1966,7 +1966,7 @@ ${helpers.single_keyword_system("font-variant-position", } SpecifiedValue::System(_) => { <%self:nongecko_unreachable> - _context.style.cached_system_font.as_ref().unwrap().font_language_override + _context.cached_system_font.as_ref().unwrap().font_language_override } } @@ -2365,11 +2365,11 @@ ${helpers.single_keyword("-moz-math-variant", /// Must be called before attempting to compute a system font /// specified value pub fn resolve_system_font(system: SystemFont, context: &mut Context) { - if context.style.cached_system_font.is_none() { + if context.cached_system_font.is_none() { let computed = system.to_computed_value(context); - context.style.cached_system_font = Some(computed); + context.cached_system_font = Some(computed); } - debug_assert!(system == context.style.cached_system_font.as_ref().unwrap().system_font) + debug_assert!(system == context.cached_system_font.as_ref().unwrap().system_font) } #[derive(Clone, Debug)] diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs index 366ae8af469..9724580d678 100644 --- a/components/style/properties/properties.mako.rs +++ b/components/style/properties/properties.mako.rs @@ -13,6 +13,7 @@ use std::borrow::Cow; use std::collections::HashSet; use std::fmt; +use std::ops::Deref; use std::sync::Arc; use app_units::Au; @@ -1725,6 +1726,12 @@ impl ComputedValues { &self.${style_struct.ident} } + /// Gets an immutable reference to the refcounted value that wraps + /// `${style_struct.name}`. + pub fn ${style_struct.name_lower}_arc(&self) -> &Arc { + &self.${style_struct.ident} + } + /// Get a mutable reference to the ${style_struct.name} struct. #[inline] pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} { @@ -1737,18 +1744,13 @@ impl ComputedValues { /// Cloning the Arc here is fine because it only happens in the case where /// we have custom properties, and those are both rare and expensive. fn custom_properties(&self) -> Option> { - self.custom_properties.as_ref().map(|x| x.clone()) + self.custom_properties.clone() } /// Whether this style has a -moz-binding value. This is always false for /// Servo for obvious reasons. pub fn has_moz_binding(&self) -> bool { false } - /// Whether this style has a top-layer style. That's implemented in Gecko - /// via the -moz-top-layer property, but servo doesn't have any concept of a - /// top layer (yet, it's needed for fullscreen). - pub fn in_top_layer(&self) -> bool { false } - /// Returns whether this style's display value is equal to contents. /// /// Since this isn't supported in Servo, this is always false for Servo. @@ -1967,22 +1969,6 @@ impl ComputedValues { } } -impl ComputedValues { - /// Returns whether this computed style represents a floated object. - pub fn floated(&self) -> bool { - self.get_box().clone_float() != longhands::float::computed_value::T::none - } - - /// Returns whether this computed style represents an out of flow-positioned - /// object. - pub fn out_of_flow_positioned(&self) -> bool { - use properties::longhands::position::computed_value::T as position; - matches!(self.get_box().clone_position(), - position::absolute | position::fixed) - } -} - - /// Return a WritingMode bitflags from the relevant CSS properties. pub fn get_writing_mode(inheritedbox_style: &style_structs::InheritedBox) -> WritingMode { use logical_geometry; @@ -2034,6 +2020,176 @@ pub fn get_writing_mode(inheritedbox_style: &style_structs::InheritedBox) -> Wri flags } +/// A reference to a style struct of the parent, or our own style struct. +pub enum StyleStructRef<'a, T: 'a> { + /// A borrowed struct from the parent, for example, for inheriting style. + Borrowed(&'a Arc), + /// An owned struct, that we've already mutated. + Owned(T), +} + +impl<'a, T: 'a> StyleStructRef<'a, T> + where T: Clone, +{ + /// Ensure a mutable reference of this value exists, either cloning the + /// borrowed value, or returning the owned one. + pub fn mutate(&mut self) -> &mut T { + if let StyleStructRef::Borrowed(v) = *self { + *self = StyleStructRef::Owned((**v).clone()); + } + + match *self { + StyleStructRef::Owned(ref mut v) => v, + StyleStructRef::Borrowed(..) => unreachable!(), + } + } + + /// Returns an `Arc` to the internal struct, constructing one if + /// appropriate. + pub fn build(self) -> Arc { + match self { + StyleStructRef::Owned(v) => Arc::new(v), + StyleStructRef::Borrowed(v) => v.clone(), + } + } +} + +impl<'a, T: 'a> Deref for StyleStructRef<'a, T> { + type Target = T; + + fn deref(&self) -> &T { + match *self { + StyleStructRef::Owned(ref v) => v, + StyleStructRef::Borrowed(v) => &**v, + } + } +} + +/// A type used to compute a struct with minimal overhead. +/// +/// This allows holding references to the parent/default computed values without +/// actually cloning them, until we either build the style, or mutate the +/// inherited value. +pub struct StyleBuilder<'a> { + custom_properties: Option>, + /// The writing mode flags. + /// + /// TODO(emilio): Make private. + pub writing_mode: WritingMode, + /// The font size of the root element. + pub root_font_size: Au, + /// The keyword behind the current font-size property, if any. + pub font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + % for style_struct in data.active_style_structs(): + ${style_struct.ident}: StyleStructRef<'a, style_structs::${style_struct.name}>, + % endfor +} + +impl<'a> StyleBuilder<'a> { + /// Trivially construct a `StyleBuilder`. + pub fn new( + custom_properties: Option>, + writing_mode: WritingMode, + root_font_size: Au, + font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + % for style_struct in data.active_style_structs(): + ${style_struct.ident}: &'a Arc, + % endfor + ) -> Self { + StyleBuilder { + custom_properties: custom_properties, + writing_mode: writing_mode, + root_font_size: root_font_size, + font_size_keyword: font_size_keyword, + % for style_struct in data.active_style_structs(): + ${style_struct.ident}: StyleStructRef::Borrowed(${style_struct.ident}), + % endfor + } + } + + /// Creates a StyleBuilder holding only references to the structs of `s`, in + /// order to create a derived style. + pub fn for_derived_style(s: &'a ComputedValues) -> Self { + Self::for_inheritance(s, s) + } + + /// Inherits style from the parent element, accounting for the default + /// computed values that need to be provided as well. + pub fn for_inheritance(parent: &'a ComputedValues, default: &'a ComputedValues) -> Self { + Self::new(parent.custom_properties(), + parent.writing_mode, + parent.root_font_size, + parent.font_size_keyword, + % for style_struct in data.active_style_structs(): + % if style_struct.inherited: + parent.${style_struct.name_lower}_arc(), + % else: + default.${style_struct.name_lower}_arc(), + % endif + % endfor + ) + } + + + % for style_struct in data.active_style_structs(): + /// Gets an immutable view of the current `${style_struct.name}` style. + pub fn get_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} { + &self.${style_struct.ident} + } + + /// Gets a mutable view of the current `${style_struct.name}` style. + pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} { + self.${style_struct.ident}.mutate() + } + % endfor + + /// Returns whether this computed style represents a floated object. + pub fn floated(&self) -> bool { + self.get_box().clone_float() != longhands::float::computed_value::T::none + } + + /// Returns whether this computed style represents an out of flow-positioned + /// object. + pub fn out_of_flow_positioned(&self) -> bool { + use properties::longhands::position::computed_value::T as position; + matches!(self.get_box().clone_position(), + position::absolute | position::fixed) + } + + /// Whether this style has a top-layer style. That's implemented in Gecko + /// via the -moz-top-layer property, but servo doesn't have any concept of a + /// top layer (yet, it's needed for fullscreen). + #[cfg(feature = "servo")] + pub fn in_top_layer(&self) -> bool { false } + + /// Whether this style has a top-layer style. + #[cfg(feature = "gecko")] + pub fn in_top_layer(&self) -> bool { + matches!(self.get_box().clone__moz_top_layer(), + longhands::_moz_top_layer::computed_value::T::top) + } + + + /// Turns this `StyleBuilder` into a proper `ComputedValues` instance. + pub fn build(self) -> ComputedValues { + ComputedValues::new(self.custom_properties, + self.writing_mode, + self.root_font_size, + self.font_size_keyword, + % for style_struct in data.active_style_structs(): + self.${style_struct.ident}.build(), + % endfor + ) + } + + /// Get the custom properties map if necessary. + /// + /// Cloning the Arc here is fine because it only happens in the case where + /// we have custom properties, and those are both rare and expensive. + fn custom_properties(&self) -> Option> { + self.custom_properties.clone() + } +} #[cfg(feature = "servo")] pub use self::lazy_static_module::INITIAL_SERVO_VALUES; @@ -2202,28 +2358,28 @@ pub fn apply_declarations<'a, F, I>(device: &Device, ::custom_properties::finish_cascade( custom_properties, &inherited_custom_properties); - let starting_style = if !flags.contains(INHERIT_ALL) { - ComputedValues::new(custom_properties, - WritingMode::empty(), - inherited_style.root_font_size, - inherited_style.font_size_keyword, - % for style_struct in data.active_style_structs(): - % if style_struct.inherited: - inherited_style.clone_${style_struct.name_lower}(), - % else: - default_style.clone_${style_struct.name_lower}(), - % endif - % endfor - ) + let builder = if !flags.contains(INHERIT_ALL) { + StyleBuilder::new(custom_properties, + WritingMode::empty(), + inherited_style.root_font_size, + inherited_style.font_size_keyword, + % for style_struct in data.active_style_structs(): + % if style_struct.inherited: + inherited_style.${style_struct.name_lower}_arc(), + % else: + default_style.${style_struct.name_lower}_arc(), + % endif + % endfor + ) } else { - ComputedValues::new(custom_properties, - WritingMode::empty(), - inherited_style.root_font_size, - inherited_style.font_size_keyword, - % for style_struct in data.active_style_structs(): - inherited_style.clone_${style_struct.name_lower}(), - % endfor - ) + StyleBuilder::new(custom_properties, + WritingMode::empty(), + inherited_style.root_font_size, + inherited_style.font_size_keyword, + % for style_struct in data.active_style_structs(): + inherited_style.${style_struct.name_lower}_arc(), + % endfor + ) }; let mut context = computed::Context { @@ -2231,8 +2387,9 @@ pub fn apply_declarations<'a, F, I>(device: &Device, device: device, inherited_style: inherited_style, layout_parent_style: layout_parent_style, - style: starting_style, + style: builder, font_metrics_provider: font_metrics_provider, + cached_system_font: None, in_media_query: false, quirks_mode: quirks_mode, }; @@ -2382,9 +2539,11 @@ pub fn apply_declarations<'a, F, I>(device: &Device, let mut style = context.style; - StyleAdjuster::new(&mut style, is_root_element) - .adjust(context.layout_parent_style, - flags.contains(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP)); + { + StyleAdjuster::new(&mut style, is_root_element) + .adjust(context.layout_parent_style, + flags.contains(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP)); + } % if product == "gecko": // FIXME(emilio): This is effectively creating a new nsStyleBackground @@ -2408,12 +2567,12 @@ pub fn apply_declarations<'a, F, I>(device: &Device, } % endif - style + style.build() } /// See StyleAdjuster::adjust_for_border_width. -pub fn adjust_border_width(style: &mut ComputedValues) { +pub fn adjust_border_width(style: &mut StyleBuilder) { % for side in ["top", "right", "bottom", "left"]: // Like calling to_computed_value, which wouldn't type check. if style.get_border().clone_border_${side}_style().none_or_hidden() && diff --git a/components/style/servo/media_queries.rs b/components/style/servo/media_queries.rs index 4756d5bb705..299970405db 100644 --- a/components/style/servo/media_queries.rs +++ b/components/style/servo/media_queries.rs @@ -11,7 +11,7 @@ use euclid::{Size2D, TypedSize2D}; use font_metrics::ServoMetricsProvider; use media_queries::MediaType; use parser::ParserContext; -use properties::ComputedValues; +use properties::{ComputedValues, StyleBuilder}; use std::fmt; use style_traits::{CSSPixel, ToCss}; use style_traits::viewport::ViewportConstraints; @@ -185,14 +185,13 @@ impl Range { device: device, inherited_style: default_values, layout_parent_style: default_values, - // This cloning business is kind of dumb.... It's because Context - // insists on having an actual ComputedValues inside itself. - style: default_values.clone(), + style: StyleBuilder::for_derived_style(default_values), // Servo doesn't support font metrics // A real provider will be needed here once we do; since // ch units can exist in media queries. font_metrics_provider: &ServoMetricsProvider, in_media_query: true, + cached_system_font: None, quirks_mode: quirks_mode, }; diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs index 217e4fa75f2..b8a71b223d7 100644 --- a/components/style/style_adjuster.rs +++ b/components/style/style_adjuster.rs @@ -6,7 +6,7 @@ //! for it to adhere to the CSS spec. use app_units::Au; -use properties::{self, ComputedValues}; +use properties::{self, ComputedValues, StyleBuilder}; use properties::longhands::display::computed_value::T as display; use properties::longhands::float::computed_value::T as float; use properties::longhands::overflow_x::computed_value::T as overflow; @@ -14,14 +14,14 @@ use properties::longhands::position::computed_value::T as position; /// An unsized struct that implements all the adjustment methods. -pub struct StyleAdjuster<'a> { - style: &'a mut ComputedValues, +pub struct StyleAdjuster<'a, 'b: 'a> { + style: &'a mut StyleBuilder<'b>, is_root_element: bool, } -impl<'a> StyleAdjuster<'a> { +impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> { /// Trivially constructs a new StyleAdjuster. - pub fn new(style: &'a mut ComputedValues, is_root_element: bool) -> Self { + pub fn new(style: &'a mut StyleBuilder<'b>, is_root_element: bool) -> Self { StyleAdjuster { style: style, is_root_element: is_root_element, @@ -264,7 +264,7 @@ impl<'a> StyleAdjuster<'a> { /// /// When comparing to Gecko, this is similar to the work done by /// `nsStyleContext::ApplyStyleFixups`. - pub fn adjust(mut self, + pub fn adjust(&mut self, layout_parent_style: &ComputedValues, skip_root_and_element_display_fixup: bool) { self.adjust_for_top_layer(); diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs index bf3685f7eca..e072108b320 100644 --- a/components/style/values/computed/mod.rs +++ b/components/style/values/computed/mod.rs @@ -8,7 +8,9 @@ use context::QuirksMode; use euclid::size::Size2D; use font_metrics::FontMetricsProvider; use media_queries::Device; -use properties::ComputedValues; +#[cfg(feature = "gecko")] +use properties; +use properties::{ComputedValues, StyleBuilder}; use std::fmt; use style_traits::ToCss; use super::{CSSFloat, CSSInteger, RGBA}; @@ -53,10 +55,23 @@ pub struct Context<'a> { /// isn't `contents`. pub layout_parent_style: &'a ComputedValues, - /// Values access through this need to be in the properties "computed + /// Values accessed through this need to be in the properties "computed /// early": color, text-decoration, font-size, display, position, float, /// border-*-style, outline-style, font-family, writing-mode... - pub style: ComputedValues, + pub style: StyleBuilder<'a>, + + /// A cached computed system font value, for use by gecko. + /// + /// See properties/longhands/font.mako.rs + #[cfg(feature = "gecko")] + pub cached_system_font: Option, + + /// A dummy option for servo so initializing a computed::Context isn't + /// painful. + /// + /// TODO(emilio): Make constructors for Context, and drop this. + #[cfg(feature = "servo")] + pub cached_system_font: Option<()>, /// A font metrics provider, used to access font metrics to implement /// font-relative units. @@ -78,9 +93,9 @@ impl<'a> Context<'a> { pub fn inherited_style(&self) -> &ComputedValues { &self.inherited_style } /// The current style. Note that only "eager" properties should be accessed /// from here, see the comment in the member. - pub fn style(&self) -> &ComputedValues { &self.style } + pub fn style(&self) -> &StyleBuilder { &self.style } /// A mutable reference to the current style. - pub fn mutate_style(&mut self) -> &mut ComputedValues { &mut self.style } + pub fn mutate_style(&mut self) -> &mut StyleBuilder<'a> { &mut self.style } } /// A trait to represent the conversion between computed and specified values. diff --git a/components/style/viewport.rs b/components/style/viewport.rs index 90811fa8549..7096c381d23 100644 --- a/components/style/viewport.rs +++ b/components/style/viewport.rs @@ -17,6 +17,7 @@ use euclid::size::TypedSize2D; use font_metrics::get_metrics_provider_for_product; use media_queries::Device; use parser::{Parse, ParserContext, log_css_error}; +use properties::StyleBuilder; use shared_lock::{SharedRwLockReadGuard, ToCssWithGuard}; use std::ascii::AsciiExt; use std::borrow::Cow; @@ -678,14 +679,17 @@ impl MaybeNew for ViewportConstraints { let provider = get_metrics_provider_for_product(); + let default_values = device.default_computed_values(); + // TODO(emilio): Stop cloning `ComputedValues` around! let context = Context { is_root_element: false, device: device, - inherited_style: device.default_computed_values(), - layout_parent_style: device.default_computed_values(), - style: device.default_computed_values().clone(), + inherited_style: default_values, + layout_parent_style: default_values, + style: StyleBuilder::for_derived_style(default_values), font_metrics_provider: &provider, + cached_system_font: None, in_media_query: false, quirks_mode: quirks_mode, }; diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index 8b52ce3ea26..63ffda73810 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -72,7 +72,7 @@ use style::keyframes::KeyframesStepValue; use style::media_queries::{MediaList, parse_media_query_list}; use style::parallel; use style::parser::{LengthParsingMode, ParserContext}; -use style::properties::{CascadeFlags, ComputedValues, Importance, ParsedDeclaration}; +use style::properties::{CascadeFlags, ComputedValues, Importance, ParsedDeclaration, StyleBuilder}; use style::properties::{PropertyDeclarationBlock, PropertyId}; use style::properties::SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP; use style::properties::animated_properties::{AnimationValue, ComputeDistance, Interpolate, TransitionProperty}; @@ -1002,14 +1002,14 @@ pub extern "C" fn Servo_ComputedValues_Inherit( let for_text = target == structs::InheritTarget::Text; let style = if let Some(reference) = maybe_arc.as_ref() { let mut style = - ComputedValues::inherit_from(reference, - &data.default_computed_values()); + StyleBuilder::for_inheritance(reference, + &data.default_computed_values()); if for_text { StyleAdjuster::new(&mut style, /* is_root = */ false) .adjust_for_text(); } - Arc::new(style) + Arc::new(style.build()) } else { debug_assert!(!for_text); data.default_computed_values().clone() @@ -2002,8 +2002,9 @@ pub extern "C" fn Servo_GetComputedKeyframeValues(keyframes: RawGeckoKeyframeLis device: &data.stylist.device, inherited_style: parent_style.unwrap_or(default_values), layout_parent_style: parent_style.unwrap_or(default_values), - style: (**style).clone(), + style: StyleBuilder::for_derived_style(&style), font_metrics_provider: &metrics, + cached_system_font: None, in_media_query: false, quirks_mode: QuirksMode::NoQuirks, }; diff --git a/tests/unit/style/parsing/image.rs b/tests/unit/style/parsing/image.rs index 158f99aaa4e..708c50b0d93 100644 --- a/tests/unit/style/parsing/image.rs +++ b/tests/unit/style/parsing/image.rs @@ -8,7 +8,7 @@ use std::f32::consts::PI; use style::context::QuirksMode; use style::font_metrics::ServoMetricsProvider; use style::media_queries::{Device, MediaType}; -use style::properties::ComputedValues; +use style::properties::{ComputedValues, StyleBuilder}; use style::values::computed; use style::values::computed::{Angle, Context, ToComputedValue}; use style::values::specified; @@ -49,7 +49,8 @@ fn test_linear_gradient() { device: &device, inherited_style: initial_style, layout_parent_style: initial_style, - style: initial_style.clone(), + style: StyleBuilder::for_derived_style(&initial_style), + cached_system_font: None, font_metrics_provider: &ServoMetricsProvider, in_media_query: false, quirks_mode: QuirksMode::NoQuirks,