From da27b613521e12f8582630ce4e8a742d7fca6ecc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Naz=C4=B1m=20Can=20Alt=C4=B1nova?= Date: Sun, 30 Oct 2016 22:35:52 +0300 Subject: [PATCH] Implement parsing/serialization for border-image-* longhands --- .../style/properties/longhand/border.mako.rs | 716 ++++++++++++++++++ components/style/values/specified/length.rs | 12 + 2 files changed, 728 insertions(+) diff --git a/components/style/properties/longhand/border.mako.rs b/components/style/properties/longhand/border.mako.rs index 40892a79ace5..9c1761ec863f 100644 --- a/components/style/properties/longhand/border.mako.rs +++ b/components/style/properties/longhand/border.mako.rs @@ -64,3 +64,719 @@ ${helpers.single_keyword("-moz-float-edge", "content-box margin-box", gecko_enum_prefix="StyleFloatEdge", products="gecko", animatable=False)} + +// https://drafts.csswg.org/css-backgrounds-3/#border-image-source +<%helpers:longhand name="border-image-source" products="none" animatable="False"> + use cssparser::ToCss; + use std::fmt; + use values::LocalToCss; + use values::NoViewportPercentage; + use values::specified::Image; + + impl NoViewportPercentage for SpecifiedValue {} + + pub mod computed_value { + use values::computed; + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct T(pub Option); + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct SpecifiedValue(pub Option); + + impl ToCss for computed_value::T { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match self.0 { + Some(ref image) => image.to_css(dest), + None => dest.write_str("none"), + } + } + } + impl ToCss for SpecifiedValue { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match self.0 { + Some(ref image) => image.to_css(dest), + None => dest.write_str("none"), + } + } + } + + #[inline] + pub fn get_initial_value() -> computed_value::T { + computed_value::T(None) + } + + impl ToComputedValue for SpecifiedValue { + type ComputedValue = computed_value::T; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::T { + match self.0 { + Some(ref image) => computed_value::T(Some(image.to_computed_value(context))), + None => computed_value::T(None), + } + } + #[inline] + fn from_computed_value(computed: &computed_value::T) -> Self { + match computed.0 { + Some(ref image) => + SpecifiedValue(Some(ToComputedValue::from_computed_value(image))), + None => SpecifiedValue(None), + } + } + } + + pub fn parse(context: &ParserContext, input: &mut Parser) -> Result { + if input.try(|input| input.expect_ident_matching("none")).is_ok() { + return Ok(SpecifiedValue(None)); + } + + Ok(SpecifiedValue(Some(try!(Image::parse(context, input))))) + } + + +<%helpers:longhand name="border-image-outset" products="none" animatable="False"> + use cssparser::ToCss; + use std::fmt; + use values::LocalToCss; + use values::NoViewportPercentage; + use values::specified::{Length, Number}; + + impl NoViewportPercentage for SpecifiedValue {} + + pub mod computed_value { + use values::computed::{Length, Number}; + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct T(pub LengthOrNumber, pub LengthOrNumber, + pub LengthOrNumber, pub LengthOrNumber); + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum LengthOrNumber { + Length(Length), + Number(Number), + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct SpecifiedValue(pub Vec); + + impl ToCss for computed_value::T { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0.to_css(dest)); + try!(dest.write_str(" ")); + try!(self.1.to_css(dest)); + try!(dest.write_str(" ")); + try!(self.2.to_css(dest)); + try!(dest.write_str(" ")); + self.3.to_css(dest) + } + } + impl ToCss for SpecifiedValue { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0[0].to_css(dest)); + for value in self.0.iter().skip(1) { + try!(dest.write_str(" ")); + try!(value.to_css(dest)); + } + Ok(()) + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum LengthOrNumber { + Length(Length), + Number(Number), + } + + impl ToCss for computed_value::LengthOrNumber { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + computed_value::LengthOrNumber::Length(len) => len.to_css(dest), + computed_value::LengthOrNumber::Number(number) => number.to_css(dest), + } + } + } + impl ToCss for LengthOrNumber { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + LengthOrNumber::Length(len) => len.to_css(dest), + LengthOrNumber::Number(number) => number.to_css(dest), + } + } + } + + impl ToComputedValue for LengthOrNumber { + type ComputedValue = computed_value::LengthOrNumber; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::LengthOrNumber { + match *self { + LengthOrNumber::Length(len) => + computed_value::LengthOrNumber::Length(len.to_computed_value(context)), + LengthOrNumber::Number(number) => + computed_value::LengthOrNumber::Number(number.to_computed_value(context)), + } + } + #[inline] + fn from_computed_value(computed: &computed_value::LengthOrNumber) -> Self { + match *computed { + computed_value::LengthOrNumber::Length(len) => + LengthOrNumber::Length(ToComputedValue::from_computed_value(&len)), + computed_value::LengthOrNumber::Number(number) => + LengthOrNumber::Number(ToComputedValue::from_computed_value(&number)), + } + } + } + + #[inline] + pub fn get_initial_value() -> computed_value::T { + computed_value::T(computed_value::LengthOrNumber::Number(0.0), + computed_value::LengthOrNumber::Number(0.0), + computed_value::LengthOrNumber::Number(0.0), + computed_value::LengthOrNumber::Number(0.0)) + } + + impl ToComputedValue for SpecifiedValue { + type ComputedValue = computed_value::T; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::T { + let length = self.0.len(); + match length { + 4 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[2].to_computed_value(context), + self.0[3].to_computed_value(context)), + 3 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[2].to_computed_value(context), + self.0[1].to_computed_value(context)), + 2 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context)), + 1 => computed_value::T(self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context)), + _ => unreachable!(), + } + } + #[inline] + fn from_computed_value(computed: &computed_value::T) -> Self { + SpecifiedValue(vec![ToComputedValue::from_computed_value(&computed.0), + ToComputedValue::from_computed_value(&computed.1), + ToComputedValue::from_computed_value(&computed.2), + ToComputedValue::from_computed_value(&computed.3)]) + } + } + + impl Parse for LengthOrNumber { + fn parse(input: &mut Parser) -> Result { + let length = input.try(|input| Length::parse(input)); + if let Ok(len) = length { + return Ok(LengthOrNumber::Length(len)); + } + + let num = try!(Number::parse_non_negative(input)); + Ok(LengthOrNumber::Number(num)) + } + } + + pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result { + let mut values = vec![]; + for _ in 0..4 { + let value = input.try(|input| LengthOrNumber::parse(input)); + match value { + Ok(val) => values.push(val), + Err(_) => break, + } + } + + if values.len() > 0 { + Ok(SpecifiedValue(values)) + } else { + Err(()) + } + } + + +// https://drafts.csswg.org/css-backgrounds-3/#border-image-repeat +<%helpers:longhand name="border-image-repeat" products="none" animatable="False"> + use cssparser::ToCss; + use std::fmt; + use values::LocalToCss; + use values::NoViewportPercentage; + + impl NoViewportPercentage for SpecifiedValue {} + + pub mod computed_value { + use super::RepeatKeyword; + use values::computed; + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct T(pub RepeatKeyword, pub RepeatKeyword); + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct SpecifiedValue(pub RepeatKeyword, + pub Option); + + define_css_keyword_enum!(RepeatKeyword: + "stretch" => Stretch, + "repeat" => Repeat, + "round" => Round, + "space" => Space); + + + impl ToCss for computed_value::T { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0.to_css(dest)); + try!(dest.write_str(" ")); + self.0.to_css(dest) + } + } + impl ToCss for SpecifiedValue { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0.to_css(dest)); + if self.1.is_some() { + try!(dest.write_str(" ")); + try!(self.0.to_css(dest)); + } + Ok(()) + } + } + + #[inline] + pub fn get_initial_value() -> computed_value::T { + computed_value::T(RepeatKeyword::Stretch, RepeatKeyword::Stretch) + } + + impl ToComputedValue for SpecifiedValue { + type ComputedValue = computed_value::T; + + #[inline] + fn to_computed_value(&self, _context: &Context) -> computed_value::T { + computed_value::T(self.0, self.1.unwrap_or(self.0)) + } + #[inline] + fn from_computed_value(computed: &computed_value::T) -> Self { + SpecifiedValue(computed.0, Some(computed.1)) + } + } + + pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result { + let first = try!(RepeatKeyword::parse(input)); + let second = input.try(RepeatKeyword::parse).ok(); + + Ok(SpecifiedValue(first, second)) + } + + +// https://drafts.csswg.org/css-backgrounds-3/#border-image-width +<%helpers:longhand name="border-image-width" products="none" animatable="False"> + use cssparser::ToCss; + use std::fmt; + use values::LocalToCss; + use values::HasViewportPercentage; + use values::specified::{LengthOrPercentage, Number}; + + impl HasViewportPercentage for SpecifiedValue { + fn has_viewport_percentage(&self) -> bool { + let mut viewport_percentage = false; + for value in self.0.clone() { + let vp = match value { + SingleSpecifiedValue::LengthOrPercentage(len) => len.has_viewport_percentage(), + _ => false, + }; + viewport_percentage = vp || viewport_percentage; + } + viewport_percentage + } + } + + pub mod computed_value { + use values::computed::{LengthOrPercentage, Number}; + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct T(pub SingleComputedValue, pub SingleComputedValue, + pub SingleComputedValue, pub SingleComputedValue); + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum SingleComputedValue { + LengthOrPercentage(LengthOrPercentage), + Number(Number), + Auto, + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct SpecifiedValue(pub Vec); + + impl ToCss for computed_value::T { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0.to_css(dest)); + try!(dest.write_str(" ")); + try!(self.1.to_css(dest)); + try!(dest.write_str(" ")); + try!(self.2.to_css(dest)); + try!(dest.write_str(" ")); + self.3.to_css(dest) + } + } + impl ToCss for SpecifiedValue { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.0[0].to_css(dest)); + for value in self.0.iter().skip(1) { + try!(dest.write_str(" ")); + try!(value.to_css(dest)); + } + Ok(()) + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum SingleSpecifiedValue { + LengthOrPercentage(LengthOrPercentage), + Number(Number), + Auto, + } + + 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::Number(number) => number.to_css(dest), + computed_value::SingleComputedValue::Auto => dest.write_str("auto"), + } + } + } + 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::Number(number) => number.to_css(dest), + SingleSpecifiedValue::Auto => dest.write_str("auto"), + } + } + } + + impl ToComputedValue for SingleSpecifiedValue { + type ComputedValue = computed_value::SingleComputedValue; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::SingleComputedValue { + match *self { + SingleSpecifiedValue::LengthOrPercentage(len) => { + computed_value::SingleComputedValue::LengthOrPercentage( + len.to_computed_value(context)) + }, + SingleSpecifiedValue::Number(number) => + computed_value::SingleComputedValue::Number(number.to_computed_value(context)), + SingleSpecifiedValue::Auto => computed_value::SingleComputedValue::Auto, + } + } + #[inline] + fn from_computed_value(computed: &computed_value::SingleComputedValue) -> Self { + match *computed { + computed_value::SingleComputedValue::LengthOrPercentage(len) => { + SingleSpecifiedValue::LengthOrPercentage( + ToComputedValue::from_computed_value(&len)) + }, + computed_value::SingleComputedValue::Number(number) => + SingleSpecifiedValue::Number(ToComputedValue::from_computed_value(&number)), + computed_value::SingleComputedValue::Auto => SingleSpecifiedValue::Auto, + } + } + } + + #[inline] + pub fn get_initial_value() -> computed_value::T { + computed_value::T(computed_value::SingleComputedValue::Number(1.0), + computed_value::SingleComputedValue::Number(1.0), + computed_value::SingleComputedValue::Number(1.0), + computed_value::SingleComputedValue::Number(1.0)) + } + + impl ToComputedValue for SpecifiedValue { + type ComputedValue = computed_value::T; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::T { + let length = self.0.len(); + match length { + 4 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[2].to_computed_value(context), + self.0[3].to_computed_value(context)), + 3 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[2].to_computed_value(context), + self.0[1].to_computed_value(context)), + 2 => computed_value::T(self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[1].to_computed_value(context)), + 1 => computed_value::T(self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context), + self.0[0].to_computed_value(context)), + _ => unreachable!(), + } + } + #[inline] + fn from_computed_value(computed: &computed_value::T) -> Self { + SpecifiedValue(vec![ToComputedValue::from_computed_value(&computed.0), + ToComputedValue::from_computed_value(&computed.1), + ToComputedValue::from_computed_value(&computed.2), + ToComputedValue::from_computed_value(&computed.3)]) + } + } + + impl Parse for SingleSpecifiedValue { + fn parse(input: &mut Parser) -> Result { + if input.try(|input| input.expect_ident_matching("auto")).is_ok() { + return Ok(SingleSpecifiedValue::Auto); + } + + if let Ok(len) = input.try(|input| LengthOrPercentage::parse(input)) { + return Ok(SingleSpecifiedValue::LengthOrPercentage(len)); + } + + let num = try!(Number::parse_non_negative(input)); + Ok(SingleSpecifiedValue::Number(num)) + } + } + + pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result { + let mut values = vec![]; + for _ in 0..4 { + let value = input.try(|input| SingleSpecifiedValue::parse(input)); + match value { + Ok(val) => values.push(val), + Err(_) => break, + } + } + + if values.len() > 0 { + Ok(SpecifiedValue(values)) + } else { + Err(()) + } + } + + +// https://drafts.csswg.org/css-backgrounds-3/#border-image-slice +<%helpers:longhand name="border-image-slice" products="none" animatable="False"> + use cssparser::ToCss; + use std::fmt; + use values::LocalToCss; + use values::NoViewportPercentage; + use values::specified::{Number, Percentage}; + + impl NoViewportPercentage for SpecifiedValue {} + + pub mod computed_value { + use values::computed::Number; + use values::specified::Percentage; + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct T { + pub corners: Vec, + pub fill: bool, + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum PercentageOrNumber { + Percentage(Percentage), + Number(Number), + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub struct SpecifiedValue { + pub corners: Vec, + pub fill: bool, + } + + impl ToCss for computed_value::T { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.corners[0].to_css(dest)); + try!(dest.write_str(" ")); + try!(self.corners[1].to_css(dest)); + try!(dest.write_str(" ")); + try!(self.corners[2].to_css(dest)); + try!(dest.write_str(" ")); + try!(self.corners[3].to_css(dest)); + + if self.fill { + try!(dest.write_str("fill")); + } + Ok(()) + } + } + impl ToCss for SpecifiedValue { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + try!(self.corners[0].to_css(dest)); + for value in self.corners.iter().skip(1) { + try!(dest.write_str(" ")); + try!(value.to_css(dest)); + } + + if self.fill { + try!(dest.write_str("fill")); + } + Ok(()) + } + } + + #[derive(Debug, Clone, PartialEq)] + #[cfg_attr(feature = "servo", derive(HeapSizeOf))] + pub enum PercentageOrNumber { + Percentage(Percentage), + Number(Number), + } + + impl ToCss for computed_value::PercentageOrNumber { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + computed_value::PercentageOrNumber::Percentage(percentage) => percentage.to_css(dest), + computed_value::PercentageOrNumber::Number(number) => number.to_css(dest), + } + } + } + impl ToCss for PercentageOrNumber { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + PercentageOrNumber::Percentage(percentage) => percentage.to_css(dest), + PercentageOrNumber::Number(number) => number.to_css(dest), + } + } + } + + impl ToComputedValue for PercentageOrNumber { + type ComputedValue = computed_value::PercentageOrNumber; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::PercentageOrNumber { + match *self { + PercentageOrNumber::Percentage(percentage) => + computed_value::PercentageOrNumber::Percentage(percentage), + PercentageOrNumber::Number(number) => + computed_value::PercentageOrNumber::Number(number.to_computed_value(context)), + } + } + #[inline] + fn from_computed_value(computed: &computed_value::PercentageOrNumber) -> Self { + match *computed { + computed_value::PercentageOrNumber::Percentage(percentage) => + PercentageOrNumber::Percentage(percentage), + computed_value::PercentageOrNumber::Number(number) => + PercentageOrNumber::Number(ToComputedValue::from_computed_value(&number)), + } + } + } + + #[inline] + pub fn get_initial_value() -> computed_value::T { + computed_value::T { + corners: vec![computed_value::PercentageOrNumber::Percentage(Percentage(1.0)), + computed_value::PercentageOrNumber::Percentage(Percentage(1.0)), + computed_value::PercentageOrNumber::Percentage(Percentage(1.0)), + computed_value::PercentageOrNumber::Percentage(Percentage(1.0))], + fill: false, + } + } + + impl ToComputedValue for SpecifiedValue { + type ComputedValue = computed_value::T; + + #[inline] + fn to_computed_value(&self, context: &Context) -> computed_value::T { + let length = self.corners.len(); + let corners = match length { + 4 => vec![self.corners[0].to_computed_value(context), + self.corners[1].to_computed_value(context), + self.corners[2].to_computed_value(context), + self.corners[3].to_computed_value(context)], + 3 => vec![self.corners[0].to_computed_value(context), + self.corners[1].to_computed_value(context), + self.corners[2].to_computed_value(context), + self.corners[1].to_computed_value(context)], + 2 => vec![self.corners[0].to_computed_value(context), + self.corners[1].to_computed_value(context), + self.corners[0].to_computed_value(context), + self.corners[1].to_computed_value(context)], + 1 => vec![self.corners[0].to_computed_value(context), + self.corners[0].to_computed_value(context), + self.corners[0].to_computed_value(context), + self.corners[0].to_computed_value(context)], + _ => unreachable!(), + }; + computed_value::T { + corners: corners, + fill: self.fill, + } + } + #[inline] + fn from_computed_value(computed: &computed_value::T) -> Self { + SpecifiedValue { + corners: vec![ToComputedValue::from_computed_value(&computed.corners[0]), + ToComputedValue::from_computed_value(&computed.corners[1]), + ToComputedValue::from_computed_value(&computed.corners[2]), + ToComputedValue::from_computed_value(&computed.corners[3])], + fill: computed.fill, + } + } + } + + impl Parse for PercentageOrNumber { + fn parse(input: &mut Parser) -> Result { + if let Ok(per) = input.try(|input| Percentage::parse(input)) { + return Ok(PercentageOrNumber::Percentage(per)); + } + + let num = try!(Number::parse_non_negative(input)); + Ok(PercentageOrNumber::Number(num)) + } + } + + pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result { + let mut fill = input.try(|input| input.expect_ident_matching("fill")).is_ok(); + + let mut values = vec![]; + for _ in 0..4 { + let value = input.try(|input| PercentageOrNumber::parse(input)); + match value { + Ok(val) => values.push(val), + Err(_) => break, + } + } + + if fill == false { + fill = input.try(|input| input.expect_ident_matching("fill")).is_ok(); + } + + if values.len() > 0 { + Ok(SpecifiedValue { + corners: values, + fill: fill + }) + } else { + Err(()) + } + } + diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs index 0eca7c16ac27..3ce892fdcade 100644 --- a/components/style/values/specified/length.rs +++ b/components/style/values/specified/length.rs @@ -713,6 +713,18 @@ impl ToCss for Percentage { } } +impl Parse for Percentage { + #[inline] + fn parse(input: &mut Parser) -> Result { + let context = AllowedNumericType::All; + match try!(input.next()) { + Token::Percentage(ref value) if context.is_ok(value.unit_value) => + Ok(Percentage(value.unit_value)), + _ => Err(()) + } + } +} + #[derive(Clone, PartialEq, Copy, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum LengthOrPercentage {