Changeset 224165 in webkit for trunk/Source/WebCore/css/CSSGradientValue.cpp

Timestamp:

Oct 29, 2017, 4:07:45 PM (8 years ago)

Author:

[email protected]

Message:

[Conic Gradients] Add support for parsing conic gradients
​https://bugs.webkit.org/show_bug.cgi?id=178987

Reviewed by Dean Jackson.

Source/WebCore:

Adds initial support, disabled by default, for parsing conic gradients as per
CSS 4 Images - ​https://www.w3.org/TR/css-images-4/#conic-gradients.

Test: fast/gradients/conic-gradient-parsing.html

• css/CSSGradientValue.cpp:

(WebCore::clone):
(WebCore::CSSGradientValue::isCacheable const):
(WebCore::CSSConicGradientValue::customCSSText const):
(WebCore::CSSConicGradientValue::createGradient):
(WebCore::CSSConicGradientValue::equals const):

• css/CSSGradientValue.h:

Add CSSConicGradientValue as a subclass of CSSGradientValue and implement
customCSSText() and equals(). Stub out createGradient() as painting is not
yet implemented.

• css/CSSImageGeneratorValue.cpp:

(WebCore::CSSImageGeneratorValue::image):
(WebCore::CSSImageGeneratorValue::isFixedSize const):
(WebCore::CSSImageGeneratorValue::fixedSize):
(WebCore::CSSImageGeneratorValue::isPending const):
(WebCore::CSSImageGeneratorValue::knownToBeOpaque const):
(WebCore::CSSImageGeneratorValue::loadSubimages):

• css/CSSValue.cpp:

(WebCore::CSSValue::equals const):
(WebCore::CSSValue::cssText const):
(WebCore::CSSValue::destroy):

Dispatch to CSSConicGradientValue as needed.

• css/CSSValue.h:

(WebCore::CSSValue::isImageGeneratorValue const):
(WebCore::CSSValue::isGradientValue const):
(WebCore::CSSValue::isConicGradientValue const):

Add conic gradient predicate support and update isImageGeneratorValue and
isGradientValue to include conic gradient.

• css/CSSValueKeywords.in:

Add conic-gradient and repeating-conic-gradient.

• css/parser/CSSParser.cpp:

(WebCore::CSSParserContext::CSSParserContext):
(WebCore::operator==):

• css/parser/CSSParserMode.h:

(WebCore::CSSParserContextHash::hash):

Add runtime flags to enable conic gradients.

• css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::consumeAngleOrPercent):

Helper, similar to consumeLengthOrPercent, for consumeGradientColorStops.
Corresponds to ​https://drafts.csswg.org/css-values-4/#typedef-angle-percentage

(WebCore::CSSPropertyParserHelpers::consumeGradientColorStops):

Convert to take CSSGradientValue by reference.

(WebCore::CSSPropertyParserHelpers::consumeAngularGradientColorStops):

Helper, similar to consumeGradientColorStops, but for angular color stops
used in conic gradients. Corresponds to ​https://www.w3.org/TR/css-images-4/#typedef-angular-color-stop-list
but does not yet support double position syntax.

(WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeLinearGradient):

Pass CSSGradientValue by reference.

(WebCore::CSSPropertyParserHelpers::consumeConicGradient):

Parse conic gradient.

(WebCore::CSSPropertyParserHelpers::consumeGeneratedImage):

Dispatch to consumeConicGradient for repeating and non-repeating
conic gradients.

(WebCore::CSSPropertyParserHelpers::isGeneratedImage):

Put each value on its own line to make it more readable and add CSSValueConicGradient
and CSSValueRepeatingConicGradient.

• page/Settings.yaml:

Add a setting to enable conic gradients. Disabled by default.

• features.json:

Move conic gradients to "In Development".

LayoutTests:

• http/wpt/css: Added.
• http/wpt/css/css-images-4: Added.
• http/wpt/css/css-images-4/conic-gradient-parsing-expected.txt: Added.
• http/wpt/css/css-images-4/conic-gradient-parsing.html: Added.

Add tests for basic parsing of conic gradients.

File:

• trunk/Source/WebCore/css/CSSGradientValue.cpp (modified) (3 diffs)

trunk/Source/WebCore/css/CSSGradientValue.cpp

@@ -96 +96 @@
     if (is<CSSLinearGradientValue>(value))
         return downcast<CSSLinearGradientValue>(value).clone();
-    ASSERT(is<CSSRadialGradientValue>(value));
-    return downcast<CSSRadialGradientValue>(value).clone();
+    if (is<CSSRadialGradientValue>(value))
+        return downcast<CSSRadialGradientValue>(value).clone();
+    ASSERT(is<CSSConicGradientValue>(value));
+    return downcast<CSSConicGradientValue>(value).clone();
 }
 
@@ -545 +547 @@
 bool CSSGradientValue::isCacheable() const
 {
-    for (size_t i = 0; i < m_stops.size(); ++i) {
-        const CSSGradientColorStop& stop = m_stops[i];
-
+    for (auto& stop : m_stops) {
         if (stop.m_colorIsDerivedFromElement)
             return false;
@@ -1275 +1275 @@
 }
 
+
+String CSSConicGradientValue::customCSSText() const
+{
+    StringBuilder result;
+
+    if (m_repeating)
+        result.appendLiteral("repeating-conic-gradient(");
+    else
+        result.appendLiteral("conic-gradient(");
+
+    bool wroteSomething = false;
+
+    if (m_angle) {
+        result.appendLiteral("from ");
+        result.append(m_angle->cssText());
+        wroteSomething = true;
+    }
+
+    if (m_firstX && m_firstY) {
+        if (wroteSomething)
+            result.appendLiteral(" ");
+        result.appendLiteral("at ");
+        result.append(m_firstX->cssText());
+        result.append(' ');
+        result.append(m_firstY->cssText());
+        wroteSomething = true;
+    }
+
+    if (wroteSomething)
+        result.appendLiteral(", ");
+
+    bool wroteFirstStop = false;
+    for (auto& stop : m_stops) {
+        if (wroteFirstStop)
+            result.appendLiteral(", ");
+        wroteFirstStop = true;
+        if (!stop.isMidpoint)
+            result.append(stop.m_color->cssText());
+        if (stop.m_position) {
+            if (!stop.isMidpoint)
+                result.append(' ');
+            result.append(stop.m_position->cssText());
+        }
+    }
+    
+    result.append(')');
+    return result.toString();
+}
+
+Ref<Gradient> CSSConicGradientValue::createGradient(RenderElement&, const FloatSize&)
+{
+    // FIXME: Implement.
+    return Gradient::create(FloatPoint { }, FloatPoint { });
+}
+
+bool CSSConicGradientValue::equals(const CSSConicGradientValue& other) const
+{
+    if (m_repeating != other.m_repeating)
+        return false;
+
+    if (!compareCSSValuePtr(m_angle, other.m_angle))
+        return false;
+
+    bool equalXandY = false;
+    if (m_firstX && m_firstY)
+        equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && compareCSSValuePtr(m_firstY, other.m_firstY);
+    else if (m_firstX)
+        equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && !other.m_firstY;
+    else if (m_firstY)
+        equalXandY = compareCSSValuePtr(m_firstY, other.m_firstY) && !other.m_firstX;
+    else
+        equalXandY = !other.m_firstX && !other.m_firstY;
+
+    return equalXandY && m_stops == other.m_stops;
+}
+
 } // namespace WebCore