Bug 1846632 - [css-properties-values-api] Store ComputedValue ToCss result r=fredw,emilio

Other than making some computed <color> WPTs pass, this mostly does not
change behavior.

Differential Revision: https://phabricator.services.mozilla.com/D190253

servo/components/style/custom_properties.rs

@@ -868,10 +868,14 @@ impl<'a> CustomPropertiesBuilder<'a> {
                     if let Some(registration) = custom_registration {
                         let mut input = ParserInput::new(&unparsed_value.css);
                         let mut input = Parser::new(&mut input);
-                        if ComputedRegisteredValue::compute(&mut input, registration).is_err() {
+                        if let Ok(value) =
+                            ComputedRegisteredValue::compute(&mut input, registration)
+                        {
+                            map.insert(custom_registration, name.clone(), value);
+                        } else {
                             map.remove(custom_registration, name);
-                            return;
                         }
+                        return;
                     }
                 }
                 map.insert(
@@ -1410,7 +1414,9 @@ fn substitute_references_in_value_and_apply(
             false
         } else {
             if let Some(registration) = custom_registration {
-                if ComputedRegisteredValue::compute(&mut input, registration).is_err() {
+                if let Ok(value) = ComputedRegisteredValue::compute(&mut input, registration) {
+                    custom_properties.insert(custom_registration, name.clone(), value);
+                } else {
                     handle_invalid_at_computed_value_time(
                         name,
                         custom_properties,
@@ -1418,8 +1424,8 @@ fn substitute_references_in_value_and_apply(
                         stylist,
                         is_root_element,
                     );
-                    return;
                 }
+                return;
             }
             true
         }
@@ -1518,11 +1524,10 @@ fn substitute_block<'i>(
                                 )?;
                                 let mut fallback_input = ParserInput::new(&fallback.css);
                                 let mut fallback_input = Parser::new(&mut fallback_input);
-                                let compute_result = ComputedRegisteredValue::compute(
+                                if let Err(_) = ComputedRegisteredValue::compute(
                                     &mut fallback_input,
                                     registration,
-                                );
-                                if compute_result.is_err() {
+                                ) {
                                     return Err(input
                                         .new_custom_error(StyleParseErrorKind::UnspecifiedError));
                                 }
@@ -1543,15 +1548,18 @@ fn substitute_block<'i>(
                         if let Some(registration) = registration {
                             let mut fallback_input = ParserInput::new(&fallback.css);
                             let mut fallback_input = Parser::new(&mut fallback_input);
-                            let compute_result =
-                                ComputedRegisteredValue::compute(&mut fallback_input, registration);
-                            if compute_result.is_err() {
+                            if let Ok(fallback) =
+                                ComputedRegisteredValue::compute(&mut fallback_input, registration)
+                            {
+                                partial_computed_value.push_variable(input, &fallback)?;
+                            } else {
                                 return Err(
                                     input.new_custom_error(StyleParseErrorKind::UnspecifiedError)
                                 );
                             }
+                        } else {
+                            partial_computed_value.push_variable(&input, &fallback)?;
                         }
-                        partial_computed_value.push_variable(&input, &fallback)?;
                     }
                     Ok(())
                 })?;

servo/components/style/properties_and_values/value.rs

@@ -16,7 +16,7 @@ use crate::custom_properties::ComputedValue as ComputedPropertyValue;
 use crate::parser::{Parse, ParserContext};
 use crate::stylesheets::{CssRuleType, Origin, UrlExtraData};
 use crate::values::{specified, CustomIdent};
-use cssparser::{BasicParseErrorKind, ParseErrorKind, Parser as CSSParser};
+use cssparser::{BasicParseErrorKind, ParseErrorKind, Parser as CSSParser, ParserInput};
 use selectors::matching::QuirksMode;
 use servo_arc::{Arc, ThinArc};
 use smallvec::SmallVec;
@@ -113,22 +113,34 @@ pub enum ComputedValue {
 }
 
 impl ComputedValue {
-    /// Parse and validate a registered custom property, given a string and a property registration.
+    /// Convert a registered custom property to a VariableValue, given input and a property
+    /// registration.
     pub fn compute<'i, 't>(
         input: &mut CSSParser<'i, 't>,
         registration: &PropertyRegistration,
-    ) -> Result<(), ()> {
-        let parse_result = Self::parse(
+    ) -> Result<Arc<ComputedPropertyValue>, ()> {
+        let Ok(value) = Self::parse(
             input,
             &registration.syntax,
             &registration.url_data,
             AllowComputationallyDependent::Yes,
-        );
-        if parse_result.is_err() {
+        ) else {
             return Err(());
+        };
+        // TODO(zrhoffman, bug 1846632): Use string of computed value
+        let value = value.to_css_string();
+
+        let result = {
+            let mut input = ParserInput::new(&value);
+            let mut input = CSSParser::new(&mut input);
+            // TODO(zrhoffman, bug 1858305): Get the variable without parsing
+            ComputedPropertyValue::parse(&mut input)
+        };
+        if let Ok(value) = result {
+            Ok(value)
+        } else {
+            Err(())
         }
-        // TODO(zrhoffman, 1846632): Return a CSS string for the computed value.
-        Ok(())
     }
 
     /// Parse and validate a registered custom property value according to its syntax descriptor,

testing/web-platform/meta/css/css-properties-values-api/registered-property-computation.html.ini

@@ -14,15 +14,9 @@
   [<length> values are computed correctly [14em\]]
     expected: FAIL
 
-  [<color> values are computed correctly [#ff0000\]]
-    expected: FAIL
-
   [<integer>+ values are computed correctly [15 calc(2.4) calc(2.6)\]]
     expected: FAIL
 
-  [<color> values are computed correctly [#badbee33\]]
-    expected: FAIL
-
   [<time> values are computed correctly [calc(1000ms + 1s)\]]
     expected: FAIL
 
@@ -59,15 +53,9 @@
   [<color> values are computed correctly [tomato\]]
     expected: FAIL
 
-  [<color> values are computed correctly [#000f00\]]
-    expected: FAIL
-
   [<resolution> values are computed correctly [calc(1dppx + 96dpi)\]]
     expected: FAIL
 
-  [<color> values are computed correctly [#badbee\]]
-    expected: FAIL
-
   [<length> values are computed correctly [15vmin\]]
     expected: FAIL
 
@@ -92,9 +80,6 @@
   [<color> values are computed correctly [plum\]]
     expected: FAIL
 
-  [<color> values are computed correctly [#00000a\]]
-    expected: FAIL
-
   [<length> values are computed correctly [calc(16px - 7em + 10vh)\]]
     expected: FAIL