Changeset 295716 in webkit for trunk/Source/WebCore/css

Timestamp:

Jun 21, 2022, 8:00:34 PM (3 years ago)

Author:

[email protected]

Message:

Implement CSSNumericValue.equals
​https://bugs.webkit.org/show_bug.cgi?id=241378

Reviewed by Chris Dumez.

This is an off-by-default experimental feature.

• LayoutTests/imported/w3c/web-platform-tests/css/css-typed-om/stylevalue-subclasses/numeric-objects/equals.tentative-expected.txt:
• Source/WebCore/bindings/js/JSCSSStyleValueCustom.cpp:

(WebCore::toJSNewlyCreated):

• Source/WebCore/css/typedom/CSSNumericValue.cpp:

(WebCore::CSSNumericValue::equals):

• Source/WebCore/css/typedom/CSSNumericValue.h:

(): Deleted.

• Source/WebCore/css/typedom/CSSStyleValue.h:

(WebCore::isCSSNumericValue):
(WebCore::isCSSMathValue):

• Source/WebCore/css/typedom/CSSUnitValue.cpp:

(WebCore::CSSUnitValue::equals const):

• Source/WebCore/css/typedom/CSSUnitValue.h:
• Source/WebCore/css/typedom/numeric/CSSMathInvert.cpp:

(WebCore::CSSMathInvert::CSSMathInvert):
(WebCore::CSSMathInvert::equals const):

• Source/WebCore/css/typedom/numeric/CSSMathInvert.h:
• Source/WebCore/css/typedom/numeric/CSSMathMax.h:
• Source/WebCore/css/typedom/numeric/CSSMathMin.h:
• Source/WebCore/css/typedom/numeric/CSSMathNegate.cpp:

(WebCore::CSSMathNegate::CSSMathNegate):
(WebCore::CSSMathNegate::equals const):

• Source/WebCore/css/typedom/numeric/CSSMathNegate.h:
• Source/WebCore/css/typedom/numeric/CSSMathProduct.h:
• Source/WebCore/css/typedom/numeric/CSSMathSum.h:
• Source/WebCore/css/typedom/numeric/CSSMathValue.h:

(WebCore::CSSMathValue::CSSMathValue):
(WebCore::CSSMathValue::equalsImpl const):

Canonical link: ​https://commits.webkit.org/251721@main

Location:

trunk/Source/WebCore/css/typedom

Files:

• CSSNumericValue.cpp (modified) (1 diff)
• CSSNumericValue.h (modified) (2 diffs)
• CSSStyleValue.h (modified) (3 diffs)
• CSSUnitValue.cpp (modified) (1 diff)
• CSSUnitValue.h (modified) (1 diff)
• numeric/CSSMathInvert.cpp (modified) (2 diffs)
• numeric/CSSMathInvert.h (modified) (1 diff)
• numeric/CSSMathMax.h (modified) (1 diff)
• numeric/CSSMathMin.h (modified) (1 diff)
• numeric/CSSMathNegate.cpp (modified) (2 diffs)
• numeric/CSSMathNegate.h (modified) (1 diff)
• numeric/CSSMathProduct.h (modified) (1 diff)
• numeric/CSSMathSum.h (modified) (1 diff)
• numeric/CSSMathValue.h (modified) (2 diffs)

trunk/Source/WebCore/css/typedom/CSSNumericValue.cpp

@@ -226 +226 @@
 }
 
-bool CSSNumericValue::equals(FixedVector<CSSNumberish>&& value)
-{
-    UNUSED_PARAM(value);
+bool CSSNumericValue::equals(FixedVector<CSSNumberish>&& values)
+{
     // https://drafts.css-houdini.org/css-typed-om/#dom-cssnumericvalue-equals
-    // FIXME: add impl.
-    return false;
+    auto numericValues = WTF::map(WTFMove(values), rectifyNumberish);
+    return WTF::allOf(numericValues, [&] (const Ref<CSSNumericValue>& value) {
+        return this->equals(value.get());
+    });
 }
 

trunk/Source/WebCore/css/typedom/CSSNumericValue.h

@@ -65 +65 @@
     static Ref<CSSNumericValue> rectifyNumberish(CSSNumberish&&);
 
-    CSSStyleValueType getType() const override { return CSSStyleValueType::CSSNumericValue; }
-
     // https://drafts.css-houdini.org/css-typed-om/#sum-value-value
     using UnitMap = HashMap<CSSUnitType, int, WTF::IntHash<CSSUnitType>, WTF::StrongEnumHashTraits<CSSUnitType>>;
@@ -75 +73 @@
     using SumValue = Vector<Addend>;
     virtual std::optional<SumValue> toSumValue() const = 0;
+    virtual bool equals(const CSSNumericValue&) const = 0;
 
 protected:

trunk/Source/WebCore/css/typedom/CSSStyleValue.h

@@ -45 +45 @@
     CSSStyleImageValue,
     CSSTransformValue,
-    CSSNumericValue,
     CSSMathInvert,
     CSSMathMin,
@@ -60 +59 @@
 {
     switch (type) {
-    case CSSStyleValueType::CSSNumericValue:
     case CSSStyleValueType::CSSMathInvert:
     case CSSStyleValueType::CSSMathMin:
@@ -89 +87 @@
     case CSSStyleValueType::CSSMathSum:
         return true;
-    case CSSStyleValueType::CSSNumericValue:
     case CSSStyleValueType::CSSUnitValue:
     case CSSStyleValueType::CSSStyleValue:

trunk/Source/WebCore/css/typedom/CSSUnitValue.cpp

@@ -175 +175 @@
 }
 
+bool CSSUnitValue::equals(const CSSNumericValue& other) const
+{
+    // https://drafts.css-houdini.org/css-typed-om/#equal-numeric-value
+    auto* otherUnitValue = dynamicDowncast<CSSUnitValue>(other);
+    if (!otherUnitValue)
+        return false;
+    return m_value == otherUnitValue->m_value && m_unit == otherUnitValue->m_unit;
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/css/typedom/CSSUnitValue.h

@@ -57 +57 @@
     CSSUnitValue(double, CSSUnitType);
 
+    CSSStyleValueType getType() const final { return CSSStyleValueType::CSSUnitValue; }
     std::optional<SumValue> toSumValue() const final;
-    CSSStyleValueType getType() const final { return CSSStyleValueType::CSSUnitValue; }
+    bool equals(const CSSNumericValue&) const final;
 
     double m_value;

trunk/Source/WebCore/css/typedom/numeric/CSSMathInvert.cpp

@@ -70 +70 @@
 CSSMathInvert::CSSMathInvert(CSSNumberish&& numberish)
     : CSSMathValue(negatedType(numberish))
-    , m_value(CSSNumericValue::rectifyNumberish(WTFMove(numberish)))
+    , m_value(rectifyNumberish(WTFMove(numberish)))
 {
 }
@@ -106 +106 @@
 }
 
+bool CSSMathInvert::equals(const CSSNumericValue& other) const
+{
+    // https://drafts.css-houdini.org/css-typed-om/#equal-numeric-value
+    auto* otherInvert = dynamicDowncast<CSSMathInvert>(other);
+    if (!otherInvert)
+        return false;
+    return m_value->equals(otherInvert->value());
+
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/css/typedom/numeric/CSSMathInvert.h

@@ -44 +44 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const final;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue&) const final;
 
     CSSMathInvert(CSSNumberish&&);

trunk/Source/WebCore/css/typedom/numeric/CSSMathMax.h

@@ -47 +47 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const final;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue& other) const final { return equalsImpl<CSSMathMax>(other); }
 
     CSSMathMax(Vector<Ref<CSSNumericValue>>&&, CSSNumericType&&);

trunk/Source/WebCore/css/typedom/numeric/CSSMathMin.h

@@ -47 +47 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const final;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue& other) const final { return equalsImpl<CSSMathMin>(other); }
 
     CSSMathMin(Vector<Ref<CSSNumericValue>>&&, CSSNumericType&&);

trunk/Source/WebCore/css/typedom/numeric/CSSMathNegate.cpp

@@ -52 +52 @@
 CSSMathNegate::CSSMathNegate(CSSNumberish&& numberish)
     : CSSMathValue(copyType(numberish))
-    , m_value(CSSNumericValue::rectifyNumberish(WTFMove(numberish)))
+    , m_value(rectifyNumberish(WTFMove(numberish)))
 {
 }
@@ -78 +78 @@
 }
 
+bool CSSMathNegate::equals(const CSSNumericValue& other) const
+{
+    // https://drafts.css-houdini.org/css-typed-om/#equal-numeric-value
+    auto* otherNegate = dynamicDowncast<CSSMathNegate>(other);
+    if (!otherNegate)
+        return false;
+    return m_value->equals(otherNegate->value());
+
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/css/typedom/numeric/CSSMathNegate.h

@@ -47 +47 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const final;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue& other) const final;
 
     CSSMathNegate(CSSNumberish&&);

trunk/Source/WebCore/css/typedom/numeric/CSSMathProduct.h

@@ -47 +47 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue& other) const final { return equalsImpl<CSSMathProduct>(other); }
 
     CSSMathProduct(Vector<Ref<CSSNumericValue>>, CSSNumericType);

trunk/Source/WebCore/css/typedom/numeric/CSSMathSum.h

@@ -48 +48 @@
     void serialize(StringBuilder&, OptionSet<SerializationArguments>) const final;
     std::optional<SumValue> toSumValue() const final;
+    bool equals(const CSSNumericValue& other) const final { return equalsImpl<CSSMathSum>(other); }
 
     CSSMathSum(Vector<Ref<CSSNumericValue>>, CSSNumericType);

trunk/Source/WebCore/css/typedom/numeric/CSSMathValue.h

@@ -29 +29 @@
 
 #include "CSSMathOperator.h"
+#include "CSSNumericArray.h"
 #include "CSSNumericValue.h"
 #include "CSSStyleValue.h"
@@ -36 +37 @@
 class CSSMathValue : public CSSNumericValue {
 public:
-    CSSMathValue(CSSNumericType type = { })
+    CSSMathValue(CSSNumericType type)
         : CSSNumericValue(WTFMove(type)) { }
     virtual CSSMathOperator getOperator() const = 0;
+
+    template <typename T>
+    bool equalsImpl(const CSSNumericValue& other) const
+    {
+        // https://drafts.css-houdini.org/css-typed-om/#equal-numeric-value
+        auto* otherT = dynamicDowncast<T>(other);
+        if (!otherT)
+            return false;
+
+        ASSERT(getType() == other.getType());
+        auto& thisValues = static_cast<const T*>(this)->values();
+        auto& otherValues = otherT->values();
+        auto length = thisValues.length();
+        if (length != otherValues.length())
+            return false;
+
+        for (size_t i = 0 ; i < length; ++i) {
+            if (!thisValues.array()[i]->equals(otherValues.array()[i].get()))
+                return false;
+        }
+
+        return true;
+
+    }
 };