Revert "Bug 1965029 - Accept CSS color syntax in input type=color r=emilio" for causing mochitest failures on test_input_color_picker_datalist.html

This reverts commit f360400.

Author: chorotan

dom/canvas/CanvasRenderingContext2D.cpp

@@ -1309,10 +1309,9 @@ CanvasRenderingContext2D::ParseColorSlow(const nsACString& aString) {
 
   PresShell* presShell = GetPresShell();
   ServoStyleSet* set = presShell ? presShell->StyleSet() : nullptr;
-  const StylePerDocumentStyleData* data = set ? set->RawData() : nullptr;
   bool wasCurrentColor = false;
   nscolor color;
-  if (ServoCSSParser::ComputeColor(data, NS_RGB(0, 0, 0), aString, &color,
+  if (ServoCSSParser::ComputeColor(set, NS_RGB(0, 0, 0), aString, &color,
                                    &wasCurrentColor, loader)) {
     result.mWasCurrentColor = wasCurrentColor;
     result.mColor.emplace(color);

dom/html/HTMLInputElement.cpp

@@ -15,7 +15,6 @@
 #include "mozilla/dom/BlobImpl.h"
 #include "mozilla/dom/CustomEvent.h"
 #include "mozilla/dom/Directory.h"
-#include "mozilla/dom/DocumentInlines.h"
 #include "mozilla/dom/DocumentOrShadowRoot.h"
 #include "mozilla/dom/ElementBinding.h"
 #include "mozilla/dom/FileSystemUtils.h"
@@ -34,7 +33,6 @@
 #include "mozilla/Maybe.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/PresShell.h"
-#include "mozilla/ServoCSSParser.h"
 #include "mozilla/StaticPrefs_dom.h"
 #include "mozilla/StaticPrefs_signon.h"
 #include "mozilla/TextUtils.h"
@@ -726,40 +724,6 @@ static bool IsPickerBlocked(Document* aDoc) {
   return true;
 }
 
-/**
- * Parse a CSS color string and convert it to the target colorspace, to match:
- * https://html.spec.whatwg.org/#update-a-color-well-control-color
- *
- * @param aValue the string to be parsed
- * @return the parsed result as a HTML compatible form
- */
-static StyleAbsoluteColor ComputeColor(Document* aDocument,
-                                       const nsAString& aValue) {
-  // A few steps are ignored given we don't support alpha and colorspace. See
-  // bug 1919718.
-  return ServoCSSParser::ComputeColorWellControlColor(
-      aDocument->EnsureStyleSet().RawData(), NS_ConvertUTF16toUTF8(aValue),
-      StyleColorSpace::Srgb);
-}
-
-/**
- * https://html.spec.whatwg.org/#serialize-a-color-well-control-color
- * https://drafts.csswg.org/css-color/#color-serialization-html-compatible-serialization-is-requested
- *
- * @param aColor The parsed color
- * @param aResult The result in the form of #ffffff.
- */
-static void SerializeColorForHTMLCompatibility(const StyleAbsoluteColor& aColor,
-                                               nsAString& aResult) {
-  // Raw StyleAbsoluteColor can have floats outside of 0-1 range e.g. when
-  // display-p3 color is converted to srgb, and ToColor guarantees to fit the
-  // values within the range.
-  nscolor color = aColor.ToColor();
-  aResult.Truncate();
-  aResult.AppendPrintf("#%02x%02x%02x", NS_GET_R(color), NS_GET_G(color),
-                       NS_GET_B(color));
-}
-
 nsTArray<nsString> HTMLInputElement::GetColorsFromList() {
   RefPtr<HTMLDataListElement> dataList = GetList();
   if (!dataList) {
@@ -776,15 +740,12 @@ nsTArray<nsString> HTMLInputElement::GetColorsFromList() {
       continue;
     }
 
-    nsAutoString value;
+    nsString value;
     option->GetValue(value);
-    // https://html.spec.whatwg.org/#update-a-color-well-control-color
-    // https://html.spec.whatwg.org/#serialize-a-color-well-control-color
-    StyleAbsoluteColor result = ComputeColor(OwnerDoc(), value);
-    // Serialization step 6: If htmlCompatible is true, then do so with
-    // HTML-compatible serialization requested.
-    SerializeColorForHTMLCompatibility(result, value);
-    colors.AppendElement(value);
+    if (IsValidSimpleColor(value)) {
+      ToLowerCase(value);
+      colors.AppendElement(value);
+    }
   }
 
   return colors;
@@ -5020,14 +4981,13 @@ void HTMLInputElement::SanitizeValue(nsAString& aValue,
       }
     } break;
     case FormControlType::InputColor: {
-      // https://html.spec.whatwg.org/#update-a-color-well-control-color
-      // https://html.spec.whatwg.org/#serialize-a-color-well-control-color
-      StyleAbsoluteColor color = ComputeColor(OwnerDoc(), aValue);
-      // Serialization step 6: If htmlCompatible is true, then do so with
-      // HTML-compatible serialization requested.
-      SerializeColorForHTMLCompatibility(color, aValue);
-      break;
-    }
+      if (IsValidSimpleColor(aValue)) {
+        ToLowerCase(aValue);
+      } else {
+        // Set default (black) color, if aValue wasn't parsed correctly.
+        aValue.AssignLiteral("#000000");
+      }
+    } break;
     default:
       break;
   }
@@ -5049,6 +5009,20 @@ Maybe<nscolor> HTMLInputElement::ParseSimpleColor(const nsAString& aColor) {
   return Some(color);
 }
 
+bool HTMLInputElement::IsValidSimpleColor(const nsAString& aValue) const {
+  if (aValue.Length() != 7 || aValue.First() != '#') {
+    return false;
+  }
+
+  for (int i = 1; i < 7; ++i) {
+    if (!IsAsciiDigit(aValue[i]) && !(aValue[i] >= 'a' && aValue[i] <= 'f') &&
+        !(aValue[i] >= 'A' && aValue[i] <= 'F')) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool HTMLInputElement::IsLeapYear(uint32_t aYear) const {
   if ((aYear % 4 == 0 && aYear % 100 != 0) || (aYear % 400 == 0)) {
     return true;

dom/html/HTMLInputElement.h

@@ -1127,6 +1127,14 @@ class HTMLInputElement final : public TextControlElement,
    */
   RadioGroupContainer* FindTreeRadioGroupContainer() const;
 
+  /**
+   * Parse a color string of the form #XXXXXX where X should be hexa characters
+   * @param the string to be parsed.
+   * @return whether the string is a valid simple color.
+   * Note : this function does not consider the empty string as valid.
+   */
+  bool IsValidSimpleColor(const nsAString& aValue) const;
+
   /**
    * Parse a week string of the form yyyy-Www
    * @param the string to be parsed.

layout/inspector/InspectorUtils.cpp

@@ -749,7 +749,7 @@ void InspectorUtils::RgbToColorName(GlobalObject&, uint8_t aR, uint8_t aG,
 void InspectorUtils::ColorToRGBA(GlobalObject& aGlobal,
                                  const nsACString& aColorString,
                                  Nullable<InspectorRGBATuple>& aResult) {
-  const auto* styleData = [&]() -> const StylePerDocumentStyleData* {
+  auto* styleSet = [&]() -> ServoStyleSet* {
     nsCOMPtr<nsIGlobalObject> global =
         do_QueryInterface(aGlobal.GetAsSupports());
     if (!global) {
@@ -767,11 +767,11 @@ void InspectorUtils::ColorToRGBA(GlobalObject& aGlobal,
     if (!ps) {
       return nullptr;
     }
-    return ps->StyleSet()->RawData();
+    return ps->StyleSet();
   }();
 
   nscolor color = NS_RGB(0, 0, 0);
-  if (!ServoCSSParser::ComputeColor(styleData, NS_RGB(0, 0, 0), aColorString,
+  if (!ServoCSSParser::ComputeColor(styleSet, NS_RGB(0, 0, 0), aColorString,
                                     &color)) {
     aResult.SetNull();
     return;

layout/style/ServoCSSParser.cpp

@@ -22,22 +22,16 @@ bool ServoCSSParser::IsValidCSSColor(const nsACString& aValue) {
 }
 
 /* static */
-bool ServoCSSParser::ComputeColor(const StylePerDocumentStyleData* aStyleData,
+bool ServoCSSParser::ComputeColor(ServoStyleSet* aStyleSet,
                                   nscolor aCurrentColor,
                                   const nsACString& aValue,
                                   nscolor* aResultColor, bool* aWasCurrentColor,
                                   css::Loader* aLoader) {
-  return Servo_ComputeColor(aStyleData, aCurrentColor, &aValue, aResultColor,
+  return Servo_ComputeColor(aStyleSet ? aStyleSet->RawData() : nullptr,
+                            aCurrentColor, &aValue, aResultColor,
                             aWasCurrentColor, aLoader);
 }
 
-/* static */
-StyleAbsoluteColor ServoCSSParser::ComputeColorWellControlColor(
-    const StylePerDocumentStyleData* aStyleData, const nsACString& aValue,
-    StyleColorSpace aToColorSpace) {
-  return Servo_ComputeColorWellControlColor(aStyleData, &aValue, aToColorSpace);
-}
-
 /* static */
 bool ServoCSSParser::ColorTo(const nsACString& aFromColor,
                              const nsACString& aToColorSpace,

layout/style/ServoCSSParser.h

@@ -25,16 +25,13 @@ namespace mozilla {
 struct AnimatedPropertyID;
 class ServoStyleSet;
 struct URLExtraData;
-struct StyleAbsoluteColor;
 struct StyleFontFamilyList;
 struct StyleFontStretch;
 struct StyleFontWeight;
 struct StyleFontStyle;
 struct StyleLockedDeclarationBlock;
 struct StyleParsingMode;
-struct StylePerDocumentStyleData;
 union StyleComputedFontStyleDescriptor;
-enum class StyleColorSpace : uint8_t;
 
 template <typename Integer, typename Number, typename LinearStops>
 struct StyleTimingFunction;
@@ -65,8 +62,8 @@ class ServoCSSParser {
   /**
    * Computes an nscolor from the given CSS <color> value.
    *
-   * @param aStyleData The style data to compute system colors and other special
-   *   color values.
+   * @param aStyleSet The style set whose nsPresContext will be used to
+   *   compute system colors and other special color values.
    * @param aCurrentColor The color value that currentcolor should compute to.
    * @param aValue The CSS <color> value.
    * @param aResultColor The resulting computed color value.
@@ -77,28 +74,11 @@ class ServoCSSParser {
    *   won't be reported to the console.
    * @return Whether aValue was successfully parsed and aResultColor was set.
    */
-  static bool ComputeColor(const StylePerDocumentStyleData* aStyleData,
-                           nscolor aCurrentColor, const nsACString& aValue,
-                           nscolor* aResultColor,
+  static bool ComputeColor(ServoStyleSet* aStyleSet, nscolor aCurrentColor,
+                           const nsACString& aValue, nscolor* aResultColor,
                            bool* aWasCurrentColor = nullptr,
                            css::Loader* aLoader = nullptr);
 
-  /**
-   * Computes a StyleAbsoluteColor from the given CSS <color> value, following
-   * the HTML spec:
-   * https://html.spec.whatwg.org/#update-a-color-well-control-color
-   *
-   * @param aStyleData The style data to compute system colors and other special
-   *   color values.
-   * @param aValue The CSS <color> value.
-   * @param aToColorSpace The color space to convert the color into.
-   * @return The resulting computed color value. For invalid color value, the
-   *   opaque black color will be returned.
-   */
-  static StyleAbsoluteColor ComputeColorWellControlColor(
-      const StylePerDocumentStyleData* aStyleData, const nsACString& aValue,
-      StyleColorSpace aToColorSpace);
-
   /**
   * Takes a CSS <color> and convert it to another color space.
   *

servo/ports/geckolib/glue.rs

@@ -8371,17 +8371,15 @@ pub unsafe extern "C" fn Servo_IsValidCSSColor(value: &nsACString) -> bool {
     specified::Color::is_valid(&context, &mut input)
 }
 
-struct ComputeColorResult {
-    result_color: AbsoluteColor,
-    was_current_color: bool,
-}
-
-unsafe fn compute_color(
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ComputeColor(
     raw_data: Option<&PerDocumentStyleData>,
-    current_color: &AbsoluteColor,
+    current_color: structs::nscolor,
     value: &nsACString,
+    result_color: &mut structs::nscolor,
+    was_current_color: *mut bool,
     loader: *mut Loader,
-) -> Option<ComputeColorResult> {
+) -> bool {
     let mut input = ParserInput::new(value.as_str_unchecked());
     let mut input = Parser::new(&mut input);
     let reporter = loader.as_mut().and_then(|loader| {
@@ -8409,49 +8407,19 @@ unsafe fn compute_color(
         None => None,
     };
 
-    let computed = specified::Color::parse_and_compute(&context, &mut input, device)?;
-
-    let result_color = computed.resolve_to_absolute(current_color);
-    let was_current_color = computed.is_currentcolor();
-
-    Some(ComputeColorResult {
-        result_color,
-        was_current_color,
-    })
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Servo_ComputeColor(
-    raw_data: Option<&PerDocumentStyleData>,
-    current_color: structs::nscolor,
-    value: &nsACString,
-    result_color: &mut structs::nscolor,
-    was_current_color: *mut bool,
-    loader: *mut Loader,
-) -> bool {
-    let current_color = style::gecko::values::convert_nscolor_to_absolute_color(current_color);
-    let Some(result) = compute_color(raw_data, &current_color, value, loader) else {
-        return false;
+    let computed = match specified::Color::parse_and_compute(&context, &mut input, device) {
+        Some(c) => c,
+        None => return false,
     };
 
-    *result_color = style::gecko::values::convert_absolute_color_to_nscolor(&result.result_color);
+    let current_color = style::gecko::values::convert_nscolor_to_absolute_color(current_color);
     if !was_current_color.is_null() {
-        *was_current_color = result.was_current_color
+        *was_current_color = computed.is_currentcolor();
     }
-    true
-}
 
-// This implements https://html.spec.whatwg.org/#update-a-color-well-control-color,
-// except the actual serialization steps in step 6 of "serialize a color well control color".
-#[no_mangle]
-pub unsafe extern "C" fn Servo_ComputeColorWellControlColor(
-    raw_data: Option<&PerDocumentStyleData>,
-    value: &nsACString,
-    to_color_space: ColorSpace,
-) -> style::color::AbsoluteColor {
-    compute_color(raw_data, &AbsoluteColor::BLACK, value, ptr::null_mut())
-        .map_or(AbsoluteColor::BLACK, |res| res.result_color)
-        .to_color_space(to_color_space)
+    let rgba = computed.resolve_to_absolute(&current_color);
+    *result_color = style::gecko::values::convert_absolute_color_to_nscolor(&rgba);
+    true
 }
 
 #[no_mangle]