From 971a8aa41e45b7bfcb72389b114e051286c3887f Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Jan 2017 11:49:52 -0800 Subject: [PATCH] servo: Merge #15065 - Use Box in specified values to avoid bloating inline sizes (from Manishearth:box-calclop); r=heycam For #15061 CalcLOP is a large struct, and gets used quite often. While #15063 reduces its size a bit, it will still be much larger than any of the other variants in the `specified::Length*` types, so it will still bloat sizes, especially for specified values that contain many lengths. This change boxes it in the length types, so that it just takes one word. r? @heycam Source-Repo: https://github.com/servo/servo Source-Revision: f010fb58fdb4526a76581ba6536f807f2b2a4955 --- servo/components/script/dom/element.rs | 8 +- .../style/properties/longhand/border.mako.rs | 6 +- .../style/properties/longhand/box.mako.rs | 40 ++++----- .../style/properties/longhand/effects.mako.rs | 32 ++++--- .../style/properties/longhand/font.mako.rs | 7 +- .../longhand/inherited_table.mako.rs | 19 ++-- .../longhand/inherited_text.mako.rs | 40 +++++---- .../style/properties/longhand/outline.mako.rs | 2 +- .../style/properties/shorthand/border.mako.rs | 15 +--- servo/components/style/servo/media_queries.rs | 2 +- .../components/style/values/computed/image.rs | 8 +- .../style/values/computed/length.rs | 26 +++--- servo/components/style/values/computed/mod.rs | 2 +- .../style/values/specified/basic_shape.rs | 75 +++++++++------- .../style/values/specified/image.rs | 6 +- .../style/values/specified/length.rs | 67 ++++++++------ .../components/style/values/specified/mod.rs | 32 ++++--- .../style/values/specified/position.rs | 88 ++++++++++--------- servo/components/style/viewport.rs | 34 +++---- servo/tests/unit/style/media_queries.rs | 20 ++--- 20 files changed, 280 insertions(+), 249 deletions(-) diff --git a/servo/components/script/dom/element.rs b/servo/components/script/dom/element.rs index bd3925c04f9d..eb77b40b74c4 100644 --- a/servo/components/script/dom/element.rs +++ b/servo/components/script/dom/element.rs @@ -480,7 +480,7 @@ impl LayoutElementHelpers for LayoutJS { hints.push(from_declaration( PropertyDeclaration::BorderSpacing(DeclaredValue::Value( border_spacing::SpecifiedValue { - horizontal: width_value, + horizontal: width_value.clone(), vertical: width_value, })))); } @@ -625,11 +625,11 @@ impl LayoutElementHelpers for LayoutJS { let width_value = specified::BorderWidth::from_length( specified::Length::Absolute(Au::from_px(border as i32))); hints.push(from_declaration( - PropertyDeclaration::BorderTopWidth(DeclaredValue::Value(width_value)))); + PropertyDeclaration::BorderTopWidth(DeclaredValue::Value(width_value.clone())))); hints.push(from_declaration( - PropertyDeclaration::BorderLeftWidth(DeclaredValue::Value(width_value)))); + PropertyDeclaration::BorderLeftWidth(DeclaredValue::Value(width_value.clone())))); hints.push(from_declaration( - PropertyDeclaration::BorderBottomWidth(DeclaredValue::Value(width_value)))); + PropertyDeclaration::BorderBottomWidth(DeclaredValue::Value(width_value.clone())))); hints.push(from_declaration( PropertyDeclaration::BorderRightWidth(DeclaredValue::Value(width_value)))); } diff --git a/servo/components/style/properties/longhand/border.mako.rs b/servo/components/style/properties/longhand/border.mako.rs index 4cce1e4a77ff..27cd5328dd8f 100644 --- a/servo/components/style/properties/longhand/border.mako.rs +++ b/servo/components/style/properties/longhand/border.mako.rs @@ -427,7 +427,7 @@ ${helpers.single_keyword("-moz-float-edge", "content-box margin-box", impl ToCss for computed_value::SingleComputedValue { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - computed_value::SingleComputedValue::LengthOrPercentage(len) => len.to_css(dest), + computed_value::SingleComputedValue::LengthOrPercentage(ref len) => len.to_css(dest), computed_value::SingleComputedValue::Number(number) => number.to_css(dest), computed_value::SingleComputedValue::Auto => dest.write_str("auto"), } @@ -436,7 +436,7 @@ ${helpers.single_keyword("-moz-float-edge", "content-box margin-box", impl ToCss for SingleSpecifiedValue { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - SingleSpecifiedValue::LengthOrPercentage(len) => len.to_css(dest), + SingleSpecifiedValue::LengthOrPercentage(ref len) => len.to_css(dest), SingleSpecifiedValue::Number(number) => number.to_css(dest), SingleSpecifiedValue::Auto => dest.write_str("auto"), } @@ -449,7 +449,7 @@ ${helpers.single_keyword("-moz-float-edge", "content-box margin-box", #[inline] fn to_computed_value(&self, context: &Context) -> computed_value::SingleComputedValue { match *self { - SingleSpecifiedValue::LengthOrPercentage(len) => { + SingleSpecifiedValue::LengthOrPercentage(ref len) => { computed_value::SingleComputedValue::LengthOrPercentage( len.to_computed_value(context)) }, diff --git a/servo/components/style/properties/longhand/box.mako.rs b/servo/components/style/properties/longhand/box.mako.rs index 4911529b571a..ec3097210ad2 100644 --- a/servo/components/style/properties/longhand/box.mako.rs +++ b/servo/components/style/properties/longhand/box.mako.rs @@ -258,7 +258,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedValue::LengthOrPercentage(length) => length.has_viewport_percentage(), + SpecifiedValue::LengthOrPercentage(ref length) => length.has_viewport_percentage(), _ => false } } @@ -266,7 +266,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top", /// The `vertical-align` value. #[allow(non_camel_case_types)] - #[derive(Debug, Clone, PartialEq, Copy)] + #[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum SpecifiedValue { % for keyword in vertical_align_keywords: @@ -281,7 +281,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top", % for keyword in vertical_align_keywords: SpecifiedValue::${to_rust_ident(keyword)} => dest.write_str("${keyword}"), % endfor - SpecifiedValue::LengthOrPercentage(value) => value.to_css(dest), + SpecifiedValue::LengthOrPercentage(ref value) => value.to_css(dest), } } } @@ -324,7 +324,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top", % for keyword in vertical_align_keywords: T::${to_rust_ident(keyword)} => dest.write_str("${keyword}"), % endfor - T::LengthOrPercentage(value) => value.to_css(dest), + T::LengthOrPercentage(ref value) => value.to_css(dest), } } } @@ -347,7 +347,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top", computed_value::T::${to_rust_ident(keyword)} } % endfor - SpecifiedValue::LengthOrPercentage(value) => + SpecifiedValue::LengthOrPercentage(ref value) => computed_value::T::LengthOrPercentage(value.to_computed_value(context)), } } @@ -954,7 +954,7 @@ ${helpers.single_keyword("animation-fill-mode", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedValue::Repeat(length) => length.has_viewport_percentage(), + SpecifiedValue::Repeat(ref length) => length.has_viewport_percentage(), _ => false } } @@ -968,7 +968,7 @@ ${helpers.single_keyword("animation-fill-mode", pub struct T(pub Option); } - #[derive(Debug, Clone, Copy, PartialEq)] + #[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum SpecifiedValue { None, @@ -979,7 +979,7 @@ ${helpers.single_keyword("animation-fill-mode", fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match self.0 { None => dest.write_str("none"), - Some(l) => { + Some(ref l) => { try!(dest.write_str("repeat(")); try!(l.to_css(dest)); dest.write_str(")") @@ -1012,7 +1012,7 @@ ${helpers.single_keyword("animation-fill-mode", fn to_computed_value(&self, context: &Context) -> computed_value::T { match *self { SpecifiedValue::None => computed_value::T(None), - SpecifiedValue::Repeat(l) => + SpecifiedValue::Repeat(ref l) => computed_value::T(Some(l.to_computed_value(context))), } } @@ -1167,12 +1167,12 @@ ${helpers.single_keyword("animation-fill-mode", impl HasViewportPercentage for SpecifiedOperation { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedOperation::Translate(_, l1, l2, l3) => { + SpecifiedOperation::Translate(_, ref l1, ref l2, ref l3) => { l1.has_viewport_percentage() || l2.has_viewport_percentage() || l3.has_viewport_percentage() }, - SpecifiedOperation::Perspective(length) => length.has_viewport_percentage(), + SpecifiedOperation::Perspective(ref length) => length.has_viewport_percentage(), _ => false } } @@ -1183,13 +1183,13 @@ ${helpers.single_keyword("animation-fill-mode", match *self { // todo(gw): implement serialization for transform // types other than translate. - SpecifiedOperation::Matrix(_m) => { + SpecifiedOperation::Matrix(..) => { Ok(()) } - SpecifiedOperation::Skew(_sx, _sy) => { + SpecifiedOperation::Skew(..) => { Ok(()) } - SpecifiedOperation::Translate(kind, tx, ty, tz) => { + SpecifiedOperation::Translate(kind, ref tx, ref ty, ref tz) => { match kind { TranslateKind::Translate => { try!(dest.write_str("translate(")); @@ -1224,13 +1224,13 @@ ${helpers.single_keyword("animation-fill-mode", } } } - SpecifiedOperation::Scale(_sx, _sy, _sz) => { + SpecifiedOperation::Scale(..) => { Ok(()) } - SpecifiedOperation::Rotate(_ax, _ay, _az, _angle) => { + SpecifiedOperation::Rotate(..) => { Ok(()) } - SpecifiedOperation::Perspective(_p) => { + SpecifiedOperation::Perspective(_) => { Ok(()) } } @@ -1525,7 +1525,7 @@ ${helpers.single_keyword("animation-fill-mode", SpecifiedOperation::Skew(theta_x, theta_y) => { result.push(computed_value::ComputedOperation::Skew(theta_x, theta_y)); } - SpecifiedOperation::Perspective(d) => { + SpecifiedOperation::Perspective(ref d) => { result.push(computed_value::ComputedOperation::Perspective(d.to_computed_value(context))); } }; @@ -1674,7 +1674,7 @@ ${helpers.predefined_type("perspective", } } - #[derive(Clone, Copy, Debug, PartialEq)] + #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub struct SpecifiedValue { horizontal: LengthOrPercentage, @@ -1788,7 +1788,7 @@ ${helpers.single_keyword("transform-style", } } - #[derive(Clone, Copy, Debug, PartialEq)] + #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub struct SpecifiedValue { horizontal: LengthOrPercentage, diff --git a/servo/components/style/properties/longhand/effects.mako.rs b/servo/components/style/properties/longhand/effects.mako.rs index 20353a84b340..b24ffb0af07a 100644 --- a/servo/components/style/properties/longhand/effects.mako.rs +++ b/servo/components/style/properties/longhand/effects.mako.rs @@ -150,13 +150,13 @@ ${helpers.predefined_type("opacity", impl HasViewportPercentage for SpecifiedClipRect { fn has_viewport_percentage(&self) -> bool { self.top.has_viewport_percentage() || - self.right.map_or(false, |x| x.has_viewport_percentage()) || - self.bottom.map_or(false, |x| x.has_viewport_percentage()) || + self.right.as_ref().map_or(false, |x| x.has_viewport_percentage()) || + self.bottom.as_ref().map_or(false, |x| x.has_viewport_percentage()) || self.left.has_viewport_percentage() } } - #[derive(Clone, Debug, PartialEq, Copy)] + #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub struct SpecifiedClipRect { pub top: specified::Length, @@ -167,12 +167,11 @@ ${helpers.predefined_type("opacity", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { - let &SpecifiedValue(clip) = self; - clip.map_or(false, |x| x.has_viewport_percentage()) + self.0.as_ref().map_or(false, |x| x.has_viewport_percentage()) } } - #[derive(Clone, Debug, PartialEq, Copy)] + #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub struct SpecifiedValue(Option); @@ -183,14 +182,14 @@ ${helpers.predefined_type("opacity", try!(self.top.to_css(dest)); try!(dest.write_str(", ")); - if let Some(right) = self.right { + if let Some(ref right) = self.right { try!(right.to_css(dest)); try!(dest.write_str(", ")); } else { try!(dest.write_str("auto, ")); } - if let Some(bottom) = self.bottom { + if let Some(ref bottom) = self.bottom { try!(bottom.to_css(dest)); try!(dest.write_str(", ")); } else { @@ -224,10 +223,10 @@ ${helpers.predefined_type("opacity", #[inline] fn to_computed_value(&self, context: &Context) -> computed_value::T { - computed_value::T(self.0.map(|value| computed_value::ClipRect { + computed_value::T(self.0.as_ref().map(|value| computed_value::ClipRect { top: value.top.to_computed_value(context), - right: value.right.map(|right| right.to_computed_value(context)), - bottom: value.bottom.map(|bottom| bottom.to_computed_value(context)), + right: value.right.as_ref().map(|right| right.to_computed_value(context)), + bottom: value.bottom.as_ref().map(|bottom| bottom.to_computed_value(context)), left: value.left.to_computed_value(context), })) } @@ -302,8 +301,7 @@ ${helpers.predefined_type("opacity", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { - let &SpecifiedValue(ref vec) = self; - vec.iter().any(|ref x| x.has_viewport_percentage()) + self.0.iter().any(|ref x| x.has_viewport_percentage()) } } @@ -314,7 +312,7 @@ ${helpers.predefined_type("opacity", impl HasViewportPercentage for SpecifiedFilter { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedFilter::Blur(length) => length.has_viewport_percentage(), + SpecifiedFilter::Blur(ref length) => length.has_viewport_percentage(), _ => false } } @@ -439,7 +437,7 @@ ${helpers.predefined_type("opacity", impl ToCss for computed_value::Filter { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - computed_value::Filter::Blur(value) => { + computed_value::Filter::Blur(ref value) => { try!(dest.write_str("blur(")); try!(value.to_css(dest)); try!(dest.write_str(")")); @@ -477,7 +475,7 @@ ${helpers.predefined_type("opacity", impl ToCss for SpecifiedFilter { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - SpecifiedFilter::Blur(value) => { + SpecifiedFilter::Blur(ref value) => { try!(dest.write_str("blur(")); try!(value.to_css(dest)); try!(dest.write_str(")")); @@ -567,7 +565,7 @@ ${helpers.predefined_type("opacity", fn to_computed_value(&self, context: &Context) -> computed_value::T { computed_value::T{ filters: self.0.iter().map(|value| { match *value { - SpecifiedFilter::Blur(factor) => + SpecifiedFilter::Blur(ref factor) => computed_value::Filter::Blur(factor.to_computed_value(context)), SpecifiedFilter::Brightness(factor) => computed_value::Filter::Brightness(factor), SpecifiedFilter::Contrast(factor) => computed_value::Filter::Contrast(factor), diff --git a/servo/components/style/properties/longhand/font.mako.rs b/servo/components/style/properties/longhand/font.mako.rs index 2f5f3566db62..fed23f14b717 100644 --- a/servo/components/style/properties/longhand/font.mako.rs +++ b/servo/components/style/properties/longhand/font.mako.rs @@ -309,8 +309,7 @@ ${helpers.single_keyword("font-variant-caps", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { - let &SpecifiedValue(length) = self; - return length.has_viewport_percentage() + return self.0.has_viewport_percentage() } } @@ -340,13 +339,13 @@ ${helpers.single_keyword("font-variant-caps", LengthOrPercentage::Length(Length::ServoCharacterWidth(value)) => { value.to_computed_value(context.inherited_style().get_font().clone_font_size()) } - LengthOrPercentage::Length(l) => { + LengthOrPercentage::Length(ref l) => { l.to_computed_value(context) } LengthOrPercentage::Percentage(Percentage(value)) => { context.inherited_style().get_font().clone_font_size().scale_by(value) } - LengthOrPercentage::Calc(calc) => { + LengthOrPercentage::Calc(ref calc) => { let calc = calc.to_computed_value(context); calc.length() + context.inherited_style().get_font().clone_font_size() .scale_by(calc.percentage()) diff --git a/servo/components/style/properties/longhand/inherited_table.mako.rs b/servo/components/style/properties/longhand/inherited_table.mako.rs index 125477b4c46b..62d23a70b495 100644 --- a/servo/components/style/properties/longhand/inherited_table.mako.rs +++ b/servo/components/style/properties/longhand/inherited_table.mako.rs @@ -107,21 +107,26 @@ ${helpers.single_keyword("caption-side", "top bottom", } pub fn parse(_: &ParserContext, input: &mut Parser) -> Result { - let mut lengths = [ None, None ]; - for i in 0..2 { - match specified::Length::parse_non_negative(input) { - Err(()) => break, - Ok(length) => lengths[i] = Some(length), + let mut first = None; + let mut second = None; + match specified::Length::parse_non_negative(input) { + Err(()) => (), + Ok(length) => { + first = Some(length); + match specified::Length::parse_non_negative(input) { + Err(()) => (), + Ok(length) => second = Some(length), + } } } if input.next().is_ok() { return Err(()) } - match (lengths[0], lengths[1]) { + match (first, second) { (None, None) => Err(()), (Some(length), None) => { Ok(SpecifiedValue { - horizontal: length, + horizontal: length.clone(), vertical: length, }) } diff --git a/servo/components/style/properties/longhand/inherited_text.mako.rs b/servo/components/style/properties/longhand/inherited_text.mako.rs index f85e695de42b..db83c7308dfa 100644 --- a/servo/components/style/properties/longhand/inherited_text.mako.rs +++ b/servo/components/style/properties/longhand/inherited_text.mako.rs @@ -15,13 +15,13 @@ impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedValue::LengthOrPercentage(length) => length.has_viewport_percentage(), + SpecifiedValue::LengthOrPercentage(ref length) => length.has_viewport_percentage(), _ => false } } } - #[derive(Debug, Clone, PartialEq, Copy)] + #[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum SpecifiedValue { Normal, @@ -39,7 +39,7 @@ % if product == "gecko": SpecifiedValue::MozBlockHeight => dest.write_str("-moz-block-height"), % endif - SpecifiedValue::LengthOrPercentage(value) => value.to_css(dest), + SpecifiedValue::LengthOrPercentage(ref value) => value.to_css(dest), SpecifiedValue::Number(number) => write!(dest, "{}", number), } } @@ -108,15 +108,15 @@ SpecifiedValue::MozBlockHeight => computed_value::T::MozBlockHeight, % endif SpecifiedValue::Number(value) => computed_value::T::Number(value), - SpecifiedValue::LengthOrPercentage(value) => { - match value { - specified::LengthOrPercentage::Length(value) => + SpecifiedValue::LengthOrPercentage(ref value) => { + match *value { + specified::LengthOrPercentage::Length(ref value) => computed_value::T::Length(value.to_computed_value(context)), specified::LengthOrPercentage::Percentage(specified::Percentage(value)) => { let fr = specified::Length::FontRelative(specified::FontRelativeLength::Em(value)); computed_value::T::Length(fr.to_computed_value(context)) }, - specified::LengthOrPercentage::Calc(calc) => { + specified::LengthOrPercentage::Calc(ref calc) => { let calc = calc.to_computed_value(context); let fr = specified::FontRelativeLength::Em(calc.percentage()); let fr = specified::Length::FontRelative(fr); @@ -267,13 +267,13 @@ ${helpers.single_keyword("text-align-last", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedValue::Specified(length) => length.has_viewport_percentage(), + SpecifiedValue::Specified(ref length) => length.has_viewport_percentage(), _ => false } } } - #[derive(Debug, Clone, Copy, PartialEq)] + #[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum SpecifiedValue { Normal, @@ -284,7 +284,7 @@ ${helpers.single_keyword("text-align-last", fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { SpecifiedValue::Normal => dest.write_str("normal"), - SpecifiedValue::Specified(l) => l.to_css(dest), + SpecifiedValue::Specified(ref l) => l.to_css(dest), } } } @@ -317,7 +317,7 @@ ${helpers.single_keyword("text-align-last", fn to_computed_value(&self, context: &Context) -> computed_value::T { match *self { SpecifiedValue::Normal => computed_value::T(None), - SpecifiedValue::Specified(l) => + SpecifiedValue::Specified(ref l) => computed_value::T(Some(l.to_computed_value(context))) } } @@ -348,13 +348,13 @@ ${helpers.single_keyword("text-align-last", impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { match *self { - SpecifiedValue::Specified(length) => length.has_viewport_percentage(), + SpecifiedValue::Specified(ref length) => length.has_viewport_percentage(), _ => false } } } - #[derive(Debug, Clone, Copy, PartialEq)] + #[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum SpecifiedValue { Normal, @@ -365,7 +365,7 @@ ${helpers.single_keyword("text-align-last", fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { SpecifiedValue::Normal => dest.write_str("normal"), - SpecifiedValue::Specified(l) => l.to_css(dest), + SpecifiedValue::Specified(ref l) => l.to_css(dest), } } } @@ -398,7 +398,7 @@ ${helpers.single_keyword("text-align-last", fn to_computed_value(&self, context: &Context) -> computed_value::T { match *self { SpecifiedValue::Normal => computed_value::T(None), - SpecifiedValue::Specified(l) => + SpecifiedValue::Specified(ref l) => computed_value::T(Some(l.to_computed_value(context))), } } @@ -681,7 +681,9 @@ ${helpers.single_keyword("text-align-last", fn parse_one_text_shadow(context: &ParserContext, input: &mut Parser) -> Result { use app_units::Au; - let mut lengths = [specified::Length::Absolute(Au(0)); 3]; + let mut lengths = [specified::Length::Absolute(Au(0)), + specified::Length::Absolute(Au(0)), + specified::Length::Absolute(Au(0))]; let mut lengths_parsed = false; let mut color = None; @@ -723,9 +725,9 @@ ${helpers.single_keyword("text-align-last", } Ok(SpecifiedTextShadow { - offset_x: lengths[0], - offset_y: lengths[1], - blur_radius: lengths[2], + offset_x: lengths[0].take(), + offset_y: lengths[1].take(), + blur_radius: lengths[2].take(), color: color, }) } diff --git a/servo/components/style/properties/longhand/outline.mako.rs b/servo/components/style/properties/longhand/outline.mako.rs index 06b91acbca84..15f6028a9f05 100644 --- a/servo/components/style/properties/longhand/outline.mako.rs +++ b/servo/components/style/properties/longhand/outline.mako.rs @@ -48,7 +48,7 @@ ${helpers.predefined_type("outline-color", "CSSColor", "::cssparser::Color::Curr impl HasViewportPercentage for SpecifiedValue { fn has_viewport_percentage(&self) -> bool { - let &SpecifiedValue(length) = self; + let &SpecifiedValue(ref length) = self; length.has_viewport_percentage() } } diff --git a/servo/components/style/properties/shorthand/border.mako.rs b/servo/components/style/properties/shorthand/border.mako.rs index 233eb2d0df1c..c0cf0036a331 100644 --- a/servo/components/style/properties/shorthand/border.mako.rs +++ b/servo/components/style/properties/shorthand/border.mako.rs @@ -33,18 +33,7 @@ ${helpers.four_sides_shorthand("border-style", "border-%s-style", impl<'a> LonghandsToSerialize<'a> { fn to_css_declared(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { % for side in ["top", "right", "bottom", "left"]: - let ${side} = match self.border_${side}_width { - &DeclaredValue::Value(ref value) => DeclaredValue::Value(*value), - &DeclaredValue::WithVariables { - css: ref a, first_token_type: ref b, base_url: ref c, from_shorthand: ref d - } => DeclaredValue::WithVariables { - // WithVariables should not be reachable during serialization - css: a.clone(), first_token_type: b.clone(), base_url: c.clone(), from_shorthand: d.clone() - }, - &DeclaredValue::Initial => DeclaredValue::Initial, - &DeclaredValue::Inherit => DeclaredValue::Inherit, - &DeclaredValue::Unset => DeclaredValue::Unset, - }; + let ${side} = self.border_${side}_width.clone(); % endfor super::serialize_four_sides(dest, &top, &right, &bottom, &left) @@ -136,7 +125,7 @@ pub fn parse_border(context: &ParserContext, input: &mut Parser) % for side in ["top", "right", "bottom", "left"]: border_${side}_color: color.clone(), border_${side}_style: style, - border_${side}_width: width, + border_${side}_width: width.clone(), % endfor }) } diff --git a/servo/components/style/servo/media_queries.rs b/servo/components/style/servo/media_queries.rs index 6dbd78d15875..9f8b5ddf46c2 100644 --- a/servo/components/style/servo/media_queries.rs +++ b/servo/components/style/servo/media_queries.rs @@ -100,7 +100,7 @@ impl Device { /// A expression kind servo understands and parses. /// /// Only `pub` for unit testing, please don't use it directly! -#[derive(PartialEq, Copy, Clone, Debug)] +#[derive(PartialEq, Clone, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum ExpressionKind { /// http://dev.w3.org/csswg/mediaqueries-3/#width diff --git a/servo/components/style/values/computed/image.rs b/servo/components/style/values/computed/image.rs index 393253ce8057..9eb0bbc7f14c 100644 --- a/servo/components/style/values/computed/image.rs +++ b/servo/components/style/values/computed/image.rs @@ -190,7 +190,7 @@ impl ToComputedValue for specified::GradientKind { specified::GradientKind::Linear(angle_or_corner) => { GradientKind::Linear(angle_or_corner.to_computed_value(context)) }, - specified::GradientKind::Radial(ref shape, position) => { + specified::GradientKind::Radial(ref shape, ref position) => { GradientKind::Radial(shape.to_computed_value(context), position.to_computed_value(context)) }, @@ -253,7 +253,7 @@ impl ToComputedValue for specified::ColorStop { color: self.color.parsed, position: match self.position { None => None, - Some(value) => Some(value.to_computed_value(context)), + Some(ref value) => Some(value.to_computed_value(context)), }, } } @@ -374,7 +374,7 @@ impl ToComputedValue for specified::LengthOrKeyword { #[inline] fn to_computed_value(&self, context: &Context) -> LengthOrKeyword { match *self { - specified::LengthOrKeyword::Length(length) => { + specified::LengthOrKeyword::Length(ref length) => { LengthOrKeyword::Length(length.to_computed_value(context)) }, specified::LengthOrKeyword::Keyword(keyword) => { @@ -437,7 +437,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrKeyword { #[inline] fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrKeyword { match *self { - specified::LengthOrPercentageOrKeyword::LengthOrPercentage(first_len, second_len) => { + specified::LengthOrPercentageOrKeyword::LengthOrPercentage(ref first_len, ref second_len) => { LengthOrPercentageOrKeyword::LengthOrPercentage(first_len.to_computed_value(context), second_len.to_computed_value(context)) }, diff --git a/servo/components/style/values/computed/length.rs b/servo/components/style/values/computed/length.rs index 9268f5748ddb..b2a3a983e0df 100644 --- a/servo/components/style/values/computed/length.rs +++ b/servo/components/style/values/computed/length.rs @@ -194,13 +194,13 @@ impl ToComputedValue for specified::LengthOrPercentage { fn to_computed_value(&self, context: &Context) -> LengthOrPercentage { match *self { - specified::LengthOrPercentage::Length(value) => { + specified::LengthOrPercentage::Length(ref value) => { LengthOrPercentage::Length(value.to_computed_value(context)) } specified::LengthOrPercentage::Percentage(value) => { LengthOrPercentage::Percentage(value.0) } - specified::LengthOrPercentage::Calc(calc) => { + specified::LengthOrPercentage::Calc(ref calc) => { LengthOrPercentage::Calc(calc.to_computed_value(context)) } } @@ -216,9 +216,9 @@ impl ToComputedValue for specified::LengthOrPercentage { LengthOrPercentage::Percentage(value) => { specified::LengthOrPercentage::Percentage(specified::Percentage(value)) } - LengthOrPercentage::Calc(calc) => { + LengthOrPercentage::Calc(ref calc) => { specified::LengthOrPercentage::Calc( - ToComputedValue::from_computed_value(&calc) + Box::new(ToComputedValue::from_computed_value(calc)) ) } } @@ -277,7 +277,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrAuto { #[inline] fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrAuto { match *self { - specified::LengthOrPercentageOrAuto::Length(value) => { + specified::LengthOrPercentageOrAuto::Length(ref value) => { LengthOrPercentageOrAuto::Length(value.to_computed_value(context)) } specified::LengthOrPercentageOrAuto::Percentage(value) => { @@ -286,7 +286,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrAuto { specified::LengthOrPercentageOrAuto::Auto => { LengthOrPercentageOrAuto::Auto } - specified::LengthOrPercentageOrAuto::Calc(calc) => { + specified::LengthOrPercentageOrAuto::Calc(ref calc) => { LengthOrPercentageOrAuto::Calc(calc.to_computed_value(context)) } } @@ -306,7 +306,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrAuto { } LengthOrPercentageOrAuto::Calc(calc) => { specified::LengthOrPercentageOrAuto::Calc( - ToComputedValue::from_computed_value(&calc) + Box::new(ToComputedValue::from_computed_value(&calc)) ) } } @@ -354,13 +354,13 @@ impl ToComputedValue for specified::LengthOrPercentageOrAutoOrContent { #[inline] fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrAutoOrContent { match *self { - specified::LengthOrPercentageOrAutoOrContent::Length(value) => { + specified::LengthOrPercentageOrAutoOrContent::Length(ref value) => { LengthOrPercentageOrAutoOrContent::Length(value.to_computed_value(context)) }, specified::LengthOrPercentageOrAutoOrContent::Percentage(value) => { LengthOrPercentageOrAutoOrContent::Percentage(value.0) }, - specified::LengthOrPercentageOrAutoOrContent::Calc(calc) => { + specified::LengthOrPercentageOrAutoOrContent::Calc(ref calc) => { LengthOrPercentageOrAutoOrContent::Calc(calc.to_computed_value(context)) }, specified::LengthOrPercentageOrAutoOrContent::Auto => { @@ -392,7 +392,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrAutoOrContent { } LengthOrPercentageOrAutoOrContent::Calc(calc) => { specified::LengthOrPercentageOrAutoOrContent::Calc( - ToComputedValue::from_computed_value(&calc) + Box::new(ToComputedValue::from_computed_value(&calc)) ) } } @@ -439,13 +439,13 @@ impl ToComputedValue for specified::LengthOrPercentageOrNone { #[inline] fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrNone { match *self { - specified::LengthOrPercentageOrNone::Length(value) => { + specified::LengthOrPercentageOrNone::Length(ref value) => { LengthOrPercentageOrNone::Length(value.to_computed_value(context)) } specified::LengthOrPercentageOrNone::Percentage(value) => { LengthOrPercentageOrNone::Percentage(value.0) } - specified::LengthOrPercentageOrNone::Calc(calc) => { + specified::LengthOrPercentageOrNone::Calc(ref calc) => { LengthOrPercentageOrNone::Calc(calc.to_computed_value(context)) } specified::LengthOrPercentageOrNone::None => { @@ -468,7 +468,7 @@ impl ToComputedValue for specified::LengthOrPercentageOrNone { } LengthOrPercentageOrNone::Calc(calc) => { specified::LengthOrPercentageOrNone::Calc( - ToComputedValue::from_computed_value(&calc) + Box::new(ToComputedValue::from_computed_value(&calc)) ) } } diff --git a/servo/components/style/values/computed/mod.rs b/servo/components/style/values/computed/mod.rs index 8c739e4c3d71..15aa9ceaf25f 100644 --- a/servo/components/style/values/computed/mod.rs +++ b/servo/components/style/values/computed/mod.rs @@ -128,7 +128,7 @@ impl ToComputedValue for specified::Length { fn to_computed_value(&self, context: &Context) -> Au { match *self { specified::Length::Absolute(length) => length, - specified::Length::Calc(calc, range) => range.clamp(calc.to_computed_value(context).length()), + specified::Length::Calc(ref calc, range) => range.clamp(calc.to_computed_value(context).length()), specified::Length::FontRelative(length) => length.to_computed_value(context, /* use inherited */ false), specified::Length::ViewportPercentage(length) => diff --git a/servo/components/style/values/specified/basic_shape.rs b/servo/components/style/values/specified/basic_shape.rs index a4e0eefcbac7..d89f926dee40 100644 --- a/servo/components/style/values/specified/basic_shape.rs +++ b/servo/components/style/values/specified/basic_shape.rs @@ -166,9 +166,9 @@ impl Parse for BasicShape { impl ToCss for BasicShape { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - BasicShape::Inset(rect) => rect.to_css(dest), - BasicShape::Circle(circle) => circle.to_css(dest), - BasicShape::Ellipse(e) => e.to_css(dest), + BasicShape::Inset(ref rect) => rect.to_css(dest), + BasicShape::Circle(ref circle) => circle.to_css(dest), + BasicShape::Ellipse(ref e) => e.to_css(dest), BasicShape::Polygon(ref poly) => poly.to_css(dest), } } @@ -180,9 +180,9 @@ impl ToComputedValue for BasicShape { #[inline] fn to_computed_value(&self, cx: &Context) -> Self::ComputedValue { match *self { - BasicShape::Inset(rect) => computed_basic_shape::BasicShape::Inset(rect.to_computed_value(cx)), - BasicShape::Circle(circle) => computed_basic_shape::BasicShape::Circle(circle.to_computed_value(cx)), - BasicShape::Ellipse(e) => computed_basic_shape::BasicShape::Ellipse(e.to_computed_value(cx)), + BasicShape::Inset(ref rect) => computed_basic_shape::BasicShape::Inset(rect.to_computed_value(cx)), + BasicShape::Circle(ref circle) => computed_basic_shape::BasicShape::Circle(circle.to_computed_value(cx)), + BasicShape::Ellipse(ref e) => computed_basic_shape::BasicShape::Ellipse(e.to_computed_value(cx)), BasicShape::Polygon(ref poly) => computed_basic_shape::BasicShape::Polygon(poly.to_computed_value(cx)), } } @@ -205,7 +205,7 @@ impl ToComputedValue for BasicShape { } } -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] /// https://drafts.csswg.org/css-shapes/#funcdef-inset #[allow(missing_docs)] @@ -275,7 +275,7 @@ impl ToComputedValue for InsetRect { right: self.right.to_computed_value(cx), bottom: self.bottom.to_computed_value(cx), left: self.left.to_computed_value(cx), - round: self.round.map(|r| r.to_computed_value(cx)), + round: self.round.as_ref().map(|r| r.to_computed_value(cx)), } } @@ -305,6 +305,7 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) // keyword-percentage pairs can be folded into a single percentage fn fold_keyword(keyword: Option, length: Option) -> Option { + let none = length.is_none(); let pc = match length.map(replace_with_percent) { None => Percentage(0.0), // unspecified length = 0% Some(LengthOrPercentage::Percentage(pc)) => pc, @@ -313,7 +314,7 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) let percent = match keyword { Some(Keyword::Center) => { // center cannot pair with lengths - assert!(length.is_none()); + assert!(none); Percentage(0.5) }, Some(Keyword::Left) | Some(Keyword::Top) | None => pc, @@ -342,8 +343,8 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) replace_with_percent(y).to_css(dest) } - match (position.horizontal.keyword, position.horizontal.position, - position.vertical.keyword, position.vertical.position) { + match (position.horizontal.keyword, position.horizontal.position.clone(), + position.vertical.keyword, position.vertical.position.clone()) { (Some(hk), None, Some(vk), None) => { // two keywords: serialize as two lengths serialize_position_pair(hk.to_length_or_percentage(), @@ -357,7 +358,8 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) (hk, hp, vk, vp) => { // only fold if both fold; the three-value form isn't // allowed here. - if let (Some(x), Some(y)) = (fold_keyword(hk, hp), fold_keyword(vk, vp)) { + if let (Some(x), Some(y)) = (fold_keyword(hk, hp.clone()), + fold_keyword(vk, vp.clone())) { serialize_position_pair(x, y, dest) } else { // We failed to reduce it to a two-value form, @@ -365,7 +367,7 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) let zero = LengthOrPercentage::Percentage(Percentage(0.0)); try!(hk.unwrap_or(Keyword::Left).to_css(dest)); try!(dest.write_str(" ")); - try!(replace_with_percent(hp.unwrap_or(zero)).to_css(dest)); + try!(replace_with_percent(hp.unwrap_or(zero.clone())).to_css(dest)); try!(dest.write_str(" ")); try!(vk.unwrap_or(Keyword::Top).to_css(dest)); try!(dest.write_str(" ")); @@ -375,7 +377,7 @@ fn serialize_basicshape_position(position: &Position, dest: &mut W) } } -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] /// https://drafts.csswg.org/css-shapes/#funcdef-circle #[allow(missing_docs)] @@ -454,7 +456,7 @@ impl ToComputedValue for Circle { } } -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] /// https://drafts.csswg.org/css-shapes/#funcdef-ellipse #[allow(missing_docs)] @@ -508,7 +510,7 @@ impl Parse for Ellipse { impl ToCss for Ellipse { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { try!(dest.write_str("ellipse(")); - if (self.semiaxis_x, self.semiaxis_y) != Default::default() { + if !self.semiaxis_x.is_default() || !self.semiaxis_y.is_default() { try!(self.semiaxis_x.to_css(dest)); try!(dest.write_str(" ")); try!(self.semiaxis_y.to_css(dest)); @@ -635,7 +637,7 @@ impl ToComputedValue for Polygon { } /// https://drafts.csswg.org/css-shapes/#typedef-shape-radius -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum ShapeRadius { @@ -644,6 +646,16 @@ pub enum ShapeRadius { FarthestSide, } +impl ShapeRadius { + fn is_default(&self) -> bool { + if let ShapeRadius::ClosestSide = *self { + true + } else { + false + } + } +} + impl Default for ShapeRadius { fn default() -> Self { ShapeRadius::ClosestSide @@ -665,7 +677,7 @@ impl Parse for ShapeRadius { impl ToCss for ShapeRadius { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - ShapeRadius::Length(lop) => lop.to_css(dest), + ShapeRadius::Length(ref lop) => lop.to_css(dest), ShapeRadius::ClosestSide => dest.write_str("closest-side"), ShapeRadius::FarthestSide => dest.write_str("farthest-side"), } @@ -679,7 +691,7 @@ impl ToComputedValue for ShapeRadius { #[inline] fn to_computed_value(&self, cx: &Context) -> Self::ComputedValue { match *self { - ShapeRadius::Length(lop) => { + ShapeRadius::Length(ref lop) => { computed_basic_shape::ShapeRadius::Length(lop.to_computed_value(cx)) } ShapeRadius::ClosestSide => computed_basic_shape::ShapeRadius::ClosestSide, @@ -700,7 +712,7 @@ impl ToComputedValue for ShapeRadius { } /// https://drafts.csswg.org/css-backgrounds-3/#border-radius -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub struct BorderRadius { @@ -739,17 +751,20 @@ impl ToCss for BorderRadius { impl Parse for BorderRadius { fn parse(context: &ParserContext, input: &mut Parser) -> Result { - let widths = try!(parse_one_set_of_border_values(context, input)); - let heights = if input.try(|input| input.expect_delim('/')).is_ok() { + let mut widths = try!(parse_one_set_of_border_values(context, input)); + let mut heights = if input.try(|input| input.expect_delim('/')).is_ok() { try!(parse_one_set_of_border_values(context, input)) } else { - widths.clone() + [widths[0].clone(), + widths[1].clone(), + widths[2].clone(), + widths[3].clone()] }; Ok(BorderRadius { - top_left: BorderRadiusSize::new(widths[0], heights[0]), - top_right: BorderRadiusSize::new(widths[1], heights[1]), - bottom_right: BorderRadiusSize::new(widths[2], heights[2]), - bottom_left: BorderRadiusSize::new(widths[3], heights[3]), + top_left: BorderRadiusSize::new(widths[0].take(), heights[0].take()), + top_right: BorderRadiusSize::new(widths[1].take(), heights[1].take()), + bottom_right: BorderRadiusSize::new(widths[2].take(), heights[2].take()), + bottom_left: BorderRadiusSize::new(widths[3].take(), heights[3].take()), }) } } @@ -761,19 +776,19 @@ fn parse_one_set_of_border_values(context: &ParserContext, mut input: &mut Parse let b = if let Ok(b) = input.try(|i| LengthOrPercentage::parse(context, i)) { b } else { - return Ok([a, a, a, a]) + return Ok([a.clone(), a.clone(), a.clone(), a]) }; let c = if let Ok(c) = input.try(|i| LengthOrPercentage::parse(context, i)) { c } else { - return Ok([a, b, a, b]) + return Ok([a.clone(), b.clone(), a, b]) }; if let Ok(d) = input.try(|i| LengthOrPercentage::parse(context, i)) { Ok([a, b, c, d]) } else { - Ok([a, b, c, b]) + Ok([a, b.clone(), c, b]) } } diff --git a/servo/components/style/values/specified/image.rs b/servo/components/style/values/specified/image.rs index 9bf908a2ee58..3709ad20619d 100644 --- a/servo/components/style/values/specified/image.rs +++ b/servo/components/style/values/specified/image.rs @@ -80,7 +80,7 @@ impl ToCss for Gradient { skipcomma = true; } }, - GradientKind::Radial(ref shape, position) => { + GradientKind::Radial(ref shape, ref position) => { try!(dest.write_str("radial-gradient(")); try!(shape.to_css(dest)); try!(dest.write_str(" at ")); @@ -312,7 +312,7 @@ pub struct ColorStop { impl ToCss for ColorStop { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { try!(self.color.to_css(dest)); - if let Some(position) = self.position { + if let Some(ref position) = self.position { try!(dest.write_str(" ")); try!(position.to_css(dest)); } @@ -413,7 +413,7 @@ impl Parse for LengthOrPercentageOrKeyword { impl ToCss for LengthOrPercentageOrKeyword { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - LengthOrPercentageOrKeyword::LengthOrPercentage(ref first_len, second_len) => { + LengthOrPercentageOrKeyword::LengthOrPercentage(ref first_len, ref second_len) => { try!(first_len.to_css(dest)); try!(dest.write_str(" ")); second_len.to_css(dest) diff --git a/servo/components/style/values/specified/length.rs b/servo/components/style/values/specified/length.rs index 24f5563c2b9f..964a3c9b5753 100644 --- a/servo/components/style/values/specified/length.rs +++ b/servo/components/style/values/specified/length.rs @@ -11,9 +11,8 @@ use cssparser::{Parser, Token}; use euclid::size::Size2D; use font_metrics::FontMetrics; use parser::{Parse, ParserContext}; +use std::{cmp, fmt, mem}; use std::ascii::AsciiExt; -use std::cmp; -use std::fmt; use std::ops::Mul; use style_traits::ToCss; use style_traits::values::specified::AllowedNumericType; @@ -209,7 +208,7 @@ impl CharacterWidth { /// A length. /// /// https://drafts.csswg.org/css-values/#lengths -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum Length { /// An absolute length: https://drafts.csswg.org/css-values/#absolute-length @@ -237,7 +236,7 @@ pub enum Length { /// /// TODO(emilio): We have more `Calc` variants around, we should only use /// one. - Calc(CalcLengthOrPercentage, AllowedNumericType), + Calc(Box, AllowedNumericType), } impl HasViewportPercentage for Length { @@ -382,6 +381,15 @@ impl Length { pub fn from_px(px_value: CSSFloat) -> Length { Length::Absolute(Au((px_value * AU_PER_PX) as i32)) } + + /// Extract inner length without a clone, replacing it with a 0 Au + /// + /// Use when you need to move out of a length array without cloning + #[inline] + pub fn take(&mut self) -> Self { + let new = Length::Absolute(Au(0)); + mem::replace(self, new) + } } impl Parse for Length { @@ -584,7 +592,7 @@ impl CalcLengthOrPercentage { node_with_unit = Some(match *node { CalcValueNode::Sum(ref sum) => try!(CalcLengthOrPercentage::simplify_products_in_sum(sum)), - CalcValueNode::Length(l) => SimplifiedValueNode::Length(l), + CalcValueNode::Length(ref l) => SimplifiedValueNode::Length(l.clone()), CalcValueNode::Angle(a) => SimplifiedValueNode::Angle(a), CalcValueNode::Time(t) => SimplifiedValueNode::Time(t), CalcValueNode::Percentage(p) => SimplifiedValueNode::Percentage(p), @@ -604,7 +612,7 @@ impl CalcLengthOrPercentage { fn parse_length(input: &mut Parser, context: AllowedNumericType) -> Result { CalcLengthOrPercentage::parse(input, CalcUnit::Length).map(|calc| { - Length::Calc(calc, context) + Length::Calc(Box::new(calc), context) }) } @@ -844,13 +852,13 @@ impl Parse for Percentage { /// A length or a percentage value. /// /// TODO(emilio): Does this make any sense vs. CalcLengthOrPercentage? -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum LengthOrPercentage { Length(Length), Percentage(Percentage), - Calc(CalcLengthOrPercentage), + Calc(Box), } impl HasViewportPercentage for LengthOrPercentage { @@ -866,9 +874,9 @@ impl HasViewportPercentage for LengthOrPercentage { impl ToCss for LengthOrPercentage { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - LengthOrPercentage::Length(length) => length.to_css(dest), + LengthOrPercentage::Length(ref length) => length.to_css(dest), LengthOrPercentage::Percentage(percentage) => percentage.to_css(dest), - LengthOrPercentage::Calc(calc) => calc.to_css(dest), + LengthOrPercentage::Calc(ref calc) => calc.to_css(dest), } } } @@ -890,7 +898,7 @@ impl LengthOrPercentage { Ok(LengthOrPercentage::Length(Length::Absolute(Au(0)))), Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => { let calc = try!(input.parse_nested_block(CalcLengthOrPercentage::parse_length_or_percentage)); - Ok(LengthOrPercentage::Calc(calc)) + Ok(LengthOrPercentage::Calc(Box::new(calc))) }, _ => Err(()) } @@ -901,6 +909,15 @@ impl LengthOrPercentage { pub fn parse_non_negative(input: &mut Parser) -> Result { LengthOrPercentage::parse_internal(input, AllowedNumericType::NonNegative) } + + /// Extract value from ref without a clone, replacing it with a 0 Au + /// + /// Use when you need to move out of a length array without cloning + #[inline] + pub fn take(&mut self) -> Self { + let new = LengthOrPercentage::Length(Length::Absolute(Au(0))); + mem::replace(self, new) + } } impl Parse for LengthOrPercentage { @@ -912,14 +929,14 @@ impl Parse for LengthOrPercentage { /// TODO(emilio): Do the Length and Percentage variants make any sense with /// CalcLengthOrPercentage? -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum LengthOrPercentageOrAuto { Length(Length), Percentage(Percentage), Auto, - Calc(CalcLengthOrPercentage), + Calc(Box), } impl HasViewportPercentage for LengthOrPercentageOrAuto { @@ -935,10 +952,10 @@ impl HasViewportPercentage for LengthOrPercentageOrAuto { impl ToCss for LengthOrPercentageOrAuto { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - LengthOrPercentageOrAuto::Length(length) => length.to_css(dest), + LengthOrPercentageOrAuto::Length(ref length) => length.to_css(dest), LengthOrPercentageOrAuto::Percentage(percentage) => percentage.to_css(dest), LengthOrPercentageOrAuto::Auto => dest.write_str("auto"), - LengthOrPercentageOrAuto::Calc(calc) => calc.to_css(dest), + LengthOrPercentageOrAuto::Calc(ref calc) => calc.to_css(dest), } } } @@ -958,7 +975,7 @@ impl LengthOrPercentageOrAuto { Ok(LengthOrPercentageOrAuto::Auto), Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => { let calc = try!(input.parse_nested_block(CalcLengthOrPercentage::parse_length_or_percentage)); - Ok(LengthOrPercentageOrAuto::Calc(calc)) + Ok(LengthOrPercentageOrAuto::Calc(Box::new(calc))) }, _ => Err(()) } @@ -980,13 +997,13 @@ impl Parse for LengthOrPercentageOrAuto { /// TODO(emilio): Do the Length and Percentage variants make any sense with /// CalcLengthOrPercentage? -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum LengthOrPercentageOrNone { Length(Length), Percentage(Percentage), - Calc(CalcLengthOrPercentage), + Calc(Box), None, } @@ -1023,7 +1040,7 @@ impl LengthOrPercentageOrNone { Ok(LengthOrPercentageOrNone::Length(Length::Absolute(Au(0)))), Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => { let calc = try!(input.parse_nested_block(CalcLengthOrPercentage::parse_length_or_percentage)); - Ok(LengthOrPercentageOrNone::Calc(calc)) + Ok(LengthOrPercentageOrNone::Calc(Box::new(calc))) }, Token::Ident(ref value) if value.eq_ignore_ascii_case("none") => Ok(LengthOrPercentageOrNone::None), @@ -1057,7 +1074,7 @@ pub type LengthOrAuto = Either; /// `content` keyword. /// /// TODO(emilio): Do the Length and Percentage variants make any sense with -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum LengthOrPercentageOrAutoOrContent { /// A ``. @@ -1065,7 +1082,7 @@ pub enum LengthOrPercentageOrAutoOrContent { /// A percentage. Percentage(Percentage), /// A `calc` node. - Calc(CalcLengthOrPercentage), + Calc(Box), /// The `auto` keyword. Auto, /// The `content` keyword. @@ -1075,7 +1092,7 @@ pub enum LengthOrPercentageOrAutoOrContent { impl HasViewportPercentage for LengthOrPercentageOrAutoOrContent { fn has_viewport_percentage(&self) -> bool { match *self { - LengthOrPercentageOrAutoOrContent::Length(length) => length.has_viewport_percentage(), + LengthOrPercentageOrAutoOrContent::Length(ref length) => length.has_viewport_percentage(), LengthOrPercentageOrAutoOrContent::Calc(ref calc) => calc.has_viewport_percentage(), _ => false } @@ -1085,11 +1102,11 @@ impl HasViewportPercentage for LengthOrPercentageOrAutoOrContent { impl ToCss for LengthOrPercentageOrAutoOrContent { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { - LengthOrPercentageOrAutoOrContent::Length(len) => len.to_css(dest), + LengthOrPercentageOrAutoOrContent::Length(ref len) => len.to_css(dest), LengthOrPercentageOrAutoOrContent::Percentage(perc) => perc.to_css(dest), LengthOrPercentageOrAutoOrContent::Auto => dest.write_str("auto"), LengthOrPercentageOrAutoOrContent::Content => dest.write_str("content"), - LengthOrPercentageOrAutoOrContent::Calc(calc) => calc.to_css(dest), + LengthOrPercentageOrAutoOrContent::Calc(ref calc) => calc.to_css(dest), } } } @@ -1110,7 +1127,7 @@ impl Parse for LengthOrPercentageOrAutoOrContent { Ok(LengthOrPercentageOrAutoOrContent::Content), Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => { let calc = try!(input.parse_nested_block(CalcLengthOrPercentage::parse_length_or_percentage)); - Ok(LengthOrPercentageOrAutoOrContent::Calc(calc)) + Ok(LengthOrPercentageOrAutoOrContent::Calc(Box::new(calc))) }, _ => Err(()) } diff --git a/servo/components/style/values/specified/mod.rs b/servo/components/style/values/specified/mod.rs index 5ef9a1a9335d..1a5b98074059 100644 --- a/servo/components/style/values/specified/mod.rs +++ b/servo/components/style/values/specified/mod.rs @@ -122,7 +122,7 @@ impl<'a> Mul for &'a SimplifiedValueNode { #[inline] fn mul(self, scalar: CSSFloat) -> SimplifiedValueNode { match *self { - SimplifiedValueNode::Length(l) => SimplifiedValueNode::Length(l * scalar), + SimplifiedValueNode::Length(ref l) => SimplifiedValueNode::Length(l.clone() * scalar), SimplifiedValueNode::Percentage(p) => SimplifiedValueNode::Percentage(p * scalar), SimplifiedValueNode::Angle(Angle(a)) => SimplifiedValueNode::Angle(Angle(a * scalar)), SimplifiedValueNode::Time(Time(t)) => SimplifiedValueNode::Time(Time(t * scalar)), @@ -187,7 +187,7 @@ pub fn parse_number(input: &mut Parser) -> Result { } } -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub struct BorderRadiusSize(pub Size2D); @@ -198,7 +198,7 @@ impl BorderRadiusSize { #[allow(missing_docs)] pub fn zero() -> BorderRadiusSize { let zero = LengthOrPercentage::Length(Length::Absolute(Au(0))); - BorderRadiusSize(Size2D::new(zero, zero)) + BorderRadiusSize(Size2D::new(zero.clone(), zero)) } #[allow(missing_docs)] @@ -208,7 +208,7 @@ impl BorderRadiusSize { #[allow(missing_docs)] pub fn circle(radius: LengthOrPercentage) -> BorderRadiusSize { - BorderRadiusSize(Size2D::new(radius, radius)) + BorderRadiusSize(Size2D::new(radius.clone(), radius)) } } @@ -216,7 +216,8 @@ impl Parse for BorderRadiusSize { #[inline] fn parse(_context: &ParserContext, input: &mut Parser) -> Result { let first = try!(LengthOrPercentage::parse_non_negative(input)); - let second = input.try(LengthOrPercentage::parse_non_negative).unwrap_or(first); + let second = input.try(LengthOrPercentage::parse_non_negative) + .unwrap_or_else(|()| first.clone()); Ok(BorderRadiusSize(Size2D::new(first, second))) } } @@ -312,7 +313,7 @@ pub fn parse_border_width(input: &mut Parser) -> Result { }) } -#[derive(Clone, PartialEq, Copy, Debug)] +#[derive(Clone, PartialEq, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum BorderWidth { @@ -349,7 +350,7 @@ impl ToCss for BorderWidth { BorderWidth::Thin => dest.write_str("thin"), BorderWidth::Medium => dest.write_str("medium"), BorderWidth::Thick => dest.write_str("thick"), - BorderWidth::Width(length) => length.to_css(dest) + BorderWidth::Width(ref length) => length.to_css(dest) } } } @@ -358,7 +359,7 @@ impl HasViewportPercentage for BorderWidth { fn has_viewport_percentage(&self) -> bool { match *self { BorderWidth::Thin | BorderWidth::Medium | BorderWidth::Thick => false, - BorderWidth::Width(length) => length.has_viewport_percentage() + BorderWidth::Width(ref length) => length.has_viewport_percentage() } } } @@ -375,7 +376,7 @@ impl ToComputedValue for BorderWidth { BorderWidth::Thin => Length::from_px(1.).to_computed_value(context), BorderWidth::Medium => Length::from_px(3.).to_computed_value(context), BorderWidth::Thick => Length::from_px(5.).to_computed_value(context), - BorderWidth::Width(length) => length.to_computed_value(context) + BorderWidth::Width(ref length) => length.to_computed_value(context) } } @@ -605,7 +606,10 @@ impl Shadow { pub fn parse(context: &ParserContext, input: &mut Parser, disable_spread_and_inset: bool) -> Result { use app_units::Au; let length_count = if disable_spread_and_inset { 3 } else { 4 }; - let mut lengths = [Length::Absolute(Au(0)); 4]; + let mut lengths = [Length::Absolute(Au(0)), + Length::Absolute(Au(0)), + Length::Absolute(Au(0)), + Length::Absolute(Au(0))]; let mut lengths_parsed = false; let mut color = None; let mut inset = false; @@ -654,10 +658,10 @@ impl Shadow { } Ok(Shadow { - offset_x: lengths[0], - offset_y: lengths[1], - blur_radius: lengths[2], - spread_radius: if disable_spread_and_inset { Length::Absolute(Au(0)) } else { lengths[3] }, + offset_x: lengths[0].take(), + offset_y: lengths[1].take(), + blur_radius: lengths[2].take(), + spread_radius: if disable_spread_and_inset { Length::Absolute(Au(0)) } else { lengths[3].take() }, color: color, inset: inset, }) diff --git a/servo/components/style/values/specified/position.rs b/servo/components/style/values/specified/position.rs index 44dcc3919334..e102842cadc6 100644 --- a/servo/components/style/values/specified/position.rs +++ b/servo/components/style/values/specified/position.rs @@ -13,12 +13,12 @@ use parser::{Parse, ParserContext}; use std::fmt; use style_traits::ToCss; use values::HasViewportPercentage; -use values::computed::{CalcLengthOrPercentage, Context}; +use values::computed::{self, CalcLengthOrPercentage, Context}; use values::computed::{LengthOrPercentage as ComputedLengthOrPercentage, ToComputedValue}; use values::computed::position as computed_position; use values::specified::{LengthOrPercentage, Percentage}; -#[derive(Debug, Clone, PartialEq, Copy)] +#[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] /// A [position][pos]. /// @@ -38,7 +38,7 @@ impl ToCss for Position { try!(dest.write_str(" ")); space_present = true; }; - if let Some(horiz_pos) = self.horizontal.position { + if let Some(ref horiz_pos) = self.horizontal.position { try!(horiz_pos.to_css(dest)); try!(dest.write_str(" ")); space_present = true; @@ -47,7 +47,7 @@ impl ToCss for Position { try!(vert_key.to_css(dest)); space_present = false; }; - if let Some(vert_pos) = self.vertical.position { + if let Some(ref vert_pos) = self.vertical.position { if space_present == false { try!(dest.write_str(" ")); } @@ -71,23 +71,23 @@ impl Position { second_keyword: Option) -> Result { // Unwrap for checking if values are at right place. - let first_key = first_keyword.unwrap_or(PositionComponent::Keyword(Keyword::Left)); - let second_key = second_keyword.unwrap_or(PositionComponent::Keyword(Keyword::Top)); + let first_key = first_keyword.clone().unwrap_or(PositionComponent::Keyword(Keyword::Left)); + let second_key = second_keyword.clone().unwrap_or(PositionComponent::Keyword(Keyword::Top)); // Check if position specified after center keyword. - if let PositionCategory::OtherKeyword = category(first_key) { + if let PositionCategory::OtherKeyword = category(&first_key) { if let Some(_) = first_position { return Err(()); }; }; - if let PositionCategory::OtherKeyword = category(second_key) { + if let PositionCategory::OtherKeyword = category(&second_key) { if let Some(_) = second_position { return Err(()); }; }; // Check first and second keywords for both 2 and 4 value positions. - let (horiz_keyword, vert_keyword) = match (category(first_key), category(second_key)) { + let (horiz_keyword, vert_keyword) = match (category(&first_key), category(&second_key)) { // Don't allow two vertical keywords or two horizontal keywords. // also don't allow length/percentage values in the wrong position (PositionCategory::HorizontalKeyword, PositionCategory::HorizontalKeyword) | @@ -186,12 +186,12 @@ impl Parse for Position { Position::new(Some(second), Some(fourth), Some(first), Some(third)) } else { // Handle 3 value background position there are several options: - if let PositionCategory::LengthOrPercentage = category(first) { + if let PositionCategory::LengthOrPercentage = category(&first) { // "length keyword length" Position::new(Some(first), Some(third), None, Some(second)) } else { - if let PositionCategory::LengthOrPercentage = category(second) { - if let PositionCategory::LengthOrPercentage = category(third) { + if let PositionCategory::LengthOrPercentage = category(&second) { + if let PositionCategory::LengthOrPercentage = category(&third) { // "keyword length length" Position::new(Some(second), Some(third), Some(first), None) } else { @@ -206,14 +206,14 @@ impl Parse for Position { } } else { // Handle 2 value background position. - if let PositionCategory::LengthOrPercentage = category(first) { - if let PositionCategory::LengthOrPercentage = category(second) { + if let PositionCategory::LengthOrPercentage = category(&first) { + if let PositionCategory::LengthOrPercentage = category(&second) { Position::new(Some(first), Some(second), None, None) } else { Position::new(Some(first), None, None, Some(second)) } } else { - if let PositionCategory::LengthOrPercentage = category(second) { + if let PositionCategory::LengthOrPercentage = category(&second) { Position::new(None, Some(second), Some(first), None) } else { Position::new(None, None, Some(first), Some(second)) @@ -249,7 +249,7 @@ impl ToComputedValue for Position { } } -#[derive(Debug, Clone, PartialEq, Copy)] +#[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub struct HorizontalPosition { @@ -259,7 +259,7 @@ pub struct HorizontalPosition { impl HasViewportPercentage for HorizontalPosition { fn has_viewport_percentage(&self) -> bool { - self.position.map_or(false, |pos| pos.has_viewport_percentage()) + self.position.as_ref().map_or(false, |pos| pos.has_viewport_percentage()) } } @@ -271,7 +271,7 @@ impl ToCss for HorizontalPosition { keyword_present = true; }; - if let Some(position) = self.position { + if let Some(ref position) = self.position { if keyword_present { try!(dest.write_str(" ")); } @@ -287,7 +287,7 @@ impl Parse for HorizontalPosition { let first = try!(PositionComponent::parse(context, input)); let second = input.try(|i| PositionComponent::parse(context, i)).ok(); - let (keyword, position) = if let PositionCategory::LengthOrPercentage = category(first) { + let (keyword, position) = if let PositionCategory::LengthOrPercentage = category(&first) { // "length keyword?" (second, Some(first)) } else { @@ -298,7 +298,7 @@ impl Parse for HorizontalPosition { // Unwrapping and checking keyword. let keyword = match keyword { Some(PositionComponent::Keyword(key)) => { - match category(keyword.unwrap()) { + match category(keyword.as_ref().unwrap()) { PositionCategory::VerticalKeyword | PositionCategory::VerticalLogicalKeyword => return Err(()), _ => Some(key), @@ -339,10 +339,10 @@ impl ToComputedValue for HorizontalPosition { let horizontal = match keyword { // FIXME(canaltinova): Support logical keywords. Keyword::Right | Keyword::XEnd => { - if let Some(x) = self.position { - let (length, percentage) = match x { + if let Some(ref x) = self.position { + let (length, percentage) = match *x { LengthOrPercentage::Percentage(Percentage(y)) => (Au(0), Some(1.0 - y)), - LengthOrPercentage::Length(y) => (-y.to_computed_value(context), Some(1.0)), + LengthOrPercentage::Length(ref y) => (-y.to_computed_value(context), Some(1.0)), _ => (Au(0), None), }; ComputedLengthOrPercentage::Calc(CalcLengthOrPercentage { @@ -357,8 +357,8 @@ impl ToComputedValue for HorizontalPosition { keyword.to_length_or_percentage().to_computed_value(context) }, _ => { - let horiz = self.position - .unwrap_or(LengthOrPercentage::Percentage(Percentage(0.0))); + let zero = LengthOrPercentage::Percentage(Percentage(0.0)); + let horiz = self.position.as_ref().unwrap_or(&zero); horiz.to_computed_value(context) }, }; @@ -375,7 +375,7 @@ impl ToComputedValue for HorizontalPosition { } } -#[derive(Debug, Clone, PartialEq, Copy)] +#[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub struct VerticalPosition { @@ -385,7 +385,7 @@ pub struct VerticalPosition { impl HasViewportPercentage for VerticalPosition { fn has_viewport_percentage(&self) -> bool { - self.position.map_or(false, |pos| pos.has_viewport_percentage()) + self.position.as_ref().map_or(false, |pos| pos.has_viewport_percentage()) } } @@ -397,7 +397,7 @@ impl ToCss for VerticalPosition { keyword_present = true; }; - if let Some(position) = self.position { + if let Some(ref position) = self.position { if keyword_present { try!(dest.write_str(" ")); } @@ -413,7 +413,7 @@ impl Parse for VerticalPosition { let first = try!(PositionComponent::parse(context, input)); let second = input.try(|i| PositionComponent::parse(context, i)).ok(); - let (keyword, position) = if let PositionCategory::LengthOrPercentage = category(first) { + let (keyword, position) = if let PositionCategory::LengthOrPercentage = category(&first) { // "length keyword?" (second, Some(first)) } else { @@ -424,7 +424,7 @@ impl Parse for VerticalPosition { // Unwrapping and checking keyword. let keyword = match keyword { Some(PositionComponent::Keyword(key)) => { - match category(keyword.unwrap()) { + match category(keyword.as_ref().unwrap()) { PositionCategory::HorizontalKeyword | PositionCategory::HorizontalLogicalKeyword => return Err(()), _ => Some(key), @@ -465,10 +465,10 @@ impl ToComputedValue for VerticalPosition { let vertical = match keyword { // FIXME(canaltinova): Support logical keywords. Keyword::Bottom | Keyword::YEnd => { - if let Some(x) = self.position { - let (length, percentage) = match x { + if let Some(ref x) = self.position { + let (length, percentage) = match *x { LengthOrPercentage::Percentage(Percentage(y)) => (Au(0), Some(1.0 - y)), - LengthOrPercentage::Length(y) => (-y.to_computed_value(context), Some(1.0)), + LengthOrPercentage::Length(ref y) => (-y.to_computed_value(context), Some(1.0)), _ => (Au(0), None), }; ComputedLengthOrPercentage::Calc(CalcLengthOrPercentage { @@ -483,8 +483,8 @@ impl ToComputedValue for VerticalPosition { keyword.to_length_or_percentage().to_computed_value(context) }, _ => { - let vert = self.position - .unwrap_or(LengthOrPercentage::Percentage(Percentage(0.0))); + let zero = LengthOrPercentage::Percentage(Percentage(0.0)); + let vert = self.position.as_ref().unwrap_or(&zero); vert.to_computed_value(context) }, }; @@ -539,7 +539,7 @@ enum PositionCategory { /// A position component. /// /// http://dev.w3.org/csswg/css2/colors.html#propdef-background-position -#[derive(Clone, PartialEq, Copy)] +#[derive(Clone, PartialEq)] pub enum PositionComponent { /// A `` Length(LengthOrPercentage), @@ -547,8 +547,8 @@ pub enum PositionComponent { Keyword(Keyword), } -fn category(p: PositionComponent) -> PositionCategory { - if let PositionComponent::Keyword(keyword) = p { +fn category(p: &PositionComponent) -> PositionCategory { + if let PositionComponent::Keyword(keyword) = *p { match keyword { Keyword::Left | Keyword::Right => PositionCategory::HorizontalKeyword, @@ -569,7 +569,7 @@ fn category(p: PositionComponent) -> PositionCategory { impl HasViewportPercentage for PositionComponent { fn has_viewport_percentage(&self) -> bool { match *self { - PositionComponent::Length(length) => length.has_viewport_percentage(), + PositionComponent::Length(ref length) => length.has_viewport_percentage(), _ => false } } @@ -578,10 +578,12 @@ impl HasViewportPercentage for PositionComponent { impl PositionComponent { /// Convert the given position component to a length or a percentage. #[inline] - pub fn to_length_or_percentage(self) -> LengthOrPercentage { - match self { - PositionComponent::Length(value) => value, - PositionComponent::Keyword(keyword) => keyword.to_length_or_percentage(), + pub fn to_length_or_percentage_computed(&self, cx: &Context) -> computed::LengthOrPercentage { + match *self { + PositionComponent::Length(ref value) => value.to_computed_value(cx), + PositionComponent::Keyword(keyword) => { + keyword.to_length_or_percentage().to_computed_value(cx) + } } } } diff --git a/servo/components/style/viewport.rs b/servo/components/style/viewport.rs index 912bf881b535..7e98b7e2460d 100644 --- a/servo/components/style/viewport.rs +++ b/servo/components/style/viewport.rs @@ -85,7 +85,7 @@ macro_rules! declare_viewport_descriptor_inner { fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { match *self { $( - ViewportDescriptor::$assigned_variant(val) => { + ViewportDescriptor::$assigned_variant(ref val) => { try!(dest.write_str($assigned_variant_name)); try!(dest.write_str(": ")); try!(val.to_css(dest)); @@ -121,7 +121,7 @@ trait FromMeta: Sized { /// See: /// * http://dev.w3.org/csswg/css-device-adapt/#min-max-width-desc /// * http://dev.w3.org/csswg/css-device-adapt/#extend-to-zoom -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] #[allow(missing_docs)] pub enum ViewportLength { @@ -134,7 +134,7 @@ impl ToCss for ViewportLength { where W: fmt::Write, { match *self { - ViewportLength::Specified(length) => length.to_css(dest), + ViewportLength::Specified(ref length) => length.to_css(dest), ViewportLength::ExtendToZoom => write!(dest, "extend-to-zoom"), } } @@ -244,11 +244,11 @@ impl ToCss for ViewportDescriptorDeclaration { } } -fn parse_shorthand(input: &mut Parser) -> Result<[ViewportLength; 2], ()> { +fn parse_shorthand(input: &mut Parser) -> Result<(ViewportLength, ViewportLength), ()> { let min = try!(ViewportLength::parse(input)); match input.try(|input| ViewportLength::parse(input)) { - Err(()) => Ok([min, min]), - Ok(max) => Ok([min, max]) + Err(()) => Ok((min.clone(), min)), + Ok(max) => Ok((min, max)) } } @@ -282,8 +282,8 @@ impl<'a, 'b> DeclarationParser for ViewportRuleParser<'a, 'b> { let shorthand = try!(parse_shorthand(input)); let important = input.try(parse_important).is_ok(); - Ok(vec![declaration!($min(value: shorthand[0], important: important)), - declaration!($max(value: shorthand[1], important: important))]) + Ok(vec![declaration!($min(value: shorthand.0, important: important)), + declaration!($max(value: shorthand.1, important: important))]) }} } @@ -631,11 +631,11 @@ impl MaybeNew for ViewportConstraints { // collapse the list of declarations into descriptor values for declaration in &rule.declarations { match declaration.descriptor { - ViewportDescriptor::MinWidth(value) => min_width = Some(value), - ViewportDescriptor::MaxWidth(value) => max_width = Some(value), + ViewportDescriptor::MinWidth(ref value) => min_width = Some(value), + ViewportDescriptor::MaxWidth(ref value) => max_width = Some(value), - ViewportDescriptor::MinHeight(value) => min_height = Some(value), - ViewportDescriptor::MaxHeight(value) => max_height = Some(value), + ViewportDescriptor::MinHeight(ref value) => min_height = Some(value), + ViewportDescriptor::MaxHeight(ref value) => max_height = Some(value), ViewportDescriptor::Zoom(value) => initial_zoom = value.to_f32(), ViewportDescriptor::MinZoom(value) => min_zoom = value.to_f32(), @@ -654,7 +654,7 @@ impl MaybeNew for ViewportConstraints { (None, None) => None, (a, None) => a, (None, b) => b, - (a, b) => Some(a.unwrap().$op(b.unwrap())), + (Some(a), Some(b)) => Some(a.$op(b)), } } } @@ -709,14 +709,14 @@ impl MaybeNew for ViewportConstraints { macro_rules! to_pixel_length { ($value:ident, $dimension:ident, $extend_to:ident => $auto_extend_to:expr) => { if let Some($value) = $value { - match $value { - ViewportLength::Specified(length) => match length { - LengthOrPercentageOrAuto::Length(value) => + match *$value { + ViewportLength::Specified(ref length) => match *length { + LengthOrPercentageOrAuto::Length(ref value) => Some(value.to_computed_value(&context)), LengthOrPercentageOrAuto::Percentage(value) => Some(initial_viewport.$dimension.scale_by(value.0)), LengthOrPercentageOrAuto::Auto => None, - LengthOrPercentageOrAuto::Calc(calc) => { + LengthOrPercentageOrAuto::Calc(ref calc) => { let calc = calc.to_computed_value(&context); Some(initial_viewport.$dimension.scale_by(calc.percentage()) + calc.length()) } diff --git a/servo/tests/unit/style/media_queries.rs b/servo/tests/unit/style/media_queries.rs index 9c156de96fae..d6e32a9e5a59 100644 --- a/servo/tests/unit/style/media_queries.rs +++ b/servo/tests/unit/style/media_queries.rs @@ -207,7 +207,7 @@ fn test_mq_default_expressions() { assert!(q.media_type == MediaQueryType::All, css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Min(w)) => assert!(w == specified::Length::Absolute(Au::from_px(100))), + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(100))), _ => panic!("wrong expression type"), } }); @@ -219,7 +219,7 @@ fn test_mq_default_expressions() { assert!(q.media_type == MediaQueryType::All, css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Max(w)) => assert!(w == specified::Length::Absolute(Au::from_px(43))), + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(43))), _ => panic!("wrong expression type"), } }); @@ -234,7 +234,7 @@ fn test_mq_expressions() { assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Min(w)) => assert!(w == specified::Length::Absolute(Au::from_px(100))), + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(100))), _ => panic!("wrong expression type"), } }); @@ -246,7 +246,7 @@ fn test_mq_expressions() { assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Max(w)) => assert!(w == specified::Length::Absolute(Au::from_px(43))), + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(43))), _ => panic!("wrong expression type"), } }); @@ -258,7 +258,7 @@ fn test_mq_expressions() { assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Eq(w)) => assert!(w == specified::Length::Absolute(Au::from_px(43))), + ExpressionKind::Width(Range::Eq(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(43))), _ => panic!("wrong expression type"), } }); @@ -270,7 +270,7 @@ fn test_mq_expressions() { assert!(q.media_type == MediaQueryType::Unknown(Atom::from("fridge")), css.to_owned()); assert!(q.expressions.len() == 1, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Max(w)) => assert!(w == specified::Length::Absolute(Au::from_px(52))), + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(52))), _ => panic!("wrong expression type"), } }); @@ -295,11 +295,11 @@ fn test_mq_multiple_expressions() { assert!(q.media_type == MediaQueryType::All, css.to_owned()); assert!(q.expressions.len() == 2, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Min(w)) => assert!(w == specified::Length::Absolute(Au::from_px(100))), + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(100))), _ => panic!("wrong expression type"), } match *q.expressions[1].kind_for_testing() { - ExpressionKind::Width(Range::Max(w)) => assert!(w == specified::Length::Absolute(Au::from_px(200))), + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(200))), _ => panic!("wrong expression type"), } }); @@ -311,11 +311,11 @@ fn test_mq_multiple_expressions() { assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned()); assert!(q.expressions.len() == 2, css.to_owned()); match *q.expressions[0].kind_for_testing() { - ExpressionKind::Width(Range::Min(w)) => assert!(w == specified::Length::Absolute(Au::from_px(100))), + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(100))), _ => panic!("wrong expression type"), } match *q.expressions[1].kind_for_testing() { - ExpressionKind::Width(Range::Max(w)) => assert!(w == specified::Length::Absolute(Au::from_px(200))), + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::Absolute(Au::from_px(200))), _ => panic!("wrong expression type"), } });