CSS conic gradient

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 2006 matching lines @@
     CSSGradientColorStop stop;
     while (consumeCommaIncludingWhitespace(args)) {
         if (!consumeDeprecatedGradientColorStop(args, stop, cssParserMode))
             return nullptr;
         result->addStop(stop);
     }
 
     return result;
 }
 
-static bool consumeGradientColorStops(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSGradientValue* gradient)
+static bool consumeGradientColorStops(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSGradientValue* gradient,
+    CSSPrimitiveValue* (*consumePositionFunc)(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk))
 {
     bool supportsColorHints = gradient->gradientType() == CSSLinearGradient || gradient->gradientType() == CSSRadialGradient;
 
     // The first color stop cannot be a color hint.
     bool previousStopWasColorHint = true;
     do {
         CSSGradientColorStop stop;
         stop.m_color = consumeColor(range, cssParserMode);
         // Two hints in a row are not allowed.
         if (!stop.m_color && (!supportsColorHints || previousStopWasColorHint))
             return false;
         previousStopWasColorHint = !stop.m_color;
-        stop.m_position = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
+//        stop.m_position = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
+        stop.m_position = consumePositionFunc(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Forbid);
         if (!stop.m_color && !stop.m_position)
             return false;
         gradient->addStop(stop);
     } while (consumeCommaIncludingWhitespace(range));
 
     // The last color stop cannot be a color hint.
     if (previousStopWasColorHint)
         return false;
 
     // Must have 2 or more stops to be valid.
@@ skipping 29 matching lines @@
             verticalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
             if (!verticalSize)
                 return nullptr;
             consumeCommaIncludingWhitespace(args);
             result->setEndHorizontalSize(horizontalSize);
             result->setEndVerticalSize(verticalSize);
         }
     } else {
         consumeCommaIncludingWhitespace(args);
     }
-    if (!consumeGradientColorStops(args, cssParserMode, result))
+    if (!consumeGradientColorStops(args, cssParserMode, result, consumeLengthOrPercent))
         return nullptr;
 
     return result;
 }
 
 static CSSValue* consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
 {
     CSSRadialGradientValue* result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
 
     CSSPrimitiveValue* shape = nullptr;
@@ skipping 62 matching lines @@
             return nullptr;
         result->setFirstX(centerX);
         result->setFirstY(centerY);
         // Right now, CSS radial gradients have the same start and end centers.
         result->setSecondX(centerX);
         result->setSecondY(centerY);
     }
 
     if ((shape || sizeKeyword || horizontalSize || centerX || centerY) && !consumeCommaIncludingWhitespace(args))
         return nullptr;
-    if (!consumeGradientColorStops(args, cssParserMode, result))
+    if (!consumeGradientColorStops(args, cssParserMode, result, consumeLengthOrPercent))
         return nullptr;
     return result;
 }
 
 static CSSValue* consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
 {
     CSSLinearGradientValue* result = CSSLinearGradientValue::create(repeating, gradientType);
 
     bool expectComma = true;
     CSSPrimitiveValue* angle = consumeAngle(args);
@@ skipping 12 matching lines @@
         }
 
         result->setFirstX(endX);
         result->setFirstY(endY);
     } else {
         expectComma = false;
     }
 
     if (expectComma && !consumeCommaIncludingWhitespace(args))
         return nullptr;
-    if (!consumeGradientColorStops(args, cssParserMode, result))
+    if (!consumeGradientColorStops(args, cssParserMode, result, consumeLengthOrPercent))
         return nullptr;
     return result;
 }
 
+static CSSValue* consumeConicGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
+{
+    CSSConicGradientValue* result = CSSConicGradientValue::create(repeating);
+
+    CSSValue* centerX = nullptr;
+    CSSValue* centerY = nullptr;
+
+    if (args.peek().id() == CSSValueAt) {
+        args.consumeIncludingWhitespace();
+        consumePosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
+        if (!(centerX && centerY))
+            return nullptr;
+        result->setFirstX(centerX);
+        result->setFirstY(centerY);
+    }
+
+    if ((centerX || centerY) && !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    if (!consumeGradientColorStops(args, cssParserMode, result, consumeLengthOrPercent))
+        return nullptr;
+
+    return result;
+}
+
 static CSSValue* consumeImageOrNone(CSSParserTokenRange&, CSSParserContext);
 
 static CSSValue* consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context)
 {
     CSSValue* fromImageValue = consumeImageOrNone(args, context);
     if (!fromImageValue || !consumeCommaIncludingWhitespace(args))
         return nullptr;
     CSSValue* toImageValue = consumeImageOrNone(args, context);
     if (!toImageValue || !consumeCommaIncludingWhitespace(args))
         return nullptr;
@@ skipping 56 matching lines @@
             context.useCounter()->count(UseCounter::DeprecatedWebKitRadialGradient);
         result = consumeDeprecatedRadialGradient(args, context.mode(), NonRepeating);
     } else if (id == CSSValueWebkitRepeatingRadialGradient) {
         if (context.useCounter())
             context.useCounter()->count(UseCounter::DeprecatedWebKitRepeatingRadialGradient);
         result = consumeDeprecatedRadialGradient(args, context.mode(), Repeating);
     } else if (id == CSSValueWebkitCrossFade) {
         result = consumeCrossFade(args, context);
     } else if (id == CSSValuePaint) {
         result = RuntimeEnabledFeatures::cssPaintAPIEnabled() ? consumePaint(args, context) : nullptr;
+    } else if (id == CSSValueConicGradient) {
+        result = consumeConicGradient(args, context.mode(), NonRepeating);
+    } else if (id == CSSValueRepeatingConicGradient) {
+        result = consumeConicGradient(args, context.mode(), Repeating);
     }
     if (!result || !args.atEnd())
         return nullptr;
     range = rangeCopy;
     return result;
 }
 
 static bool isGeneratedImage(CSSValueID id)
 {
     return id == CSSValueLinearGradient || id == CSSValueRadialGradient
         || id == CSSValueRepeatingLinearGradient || id == CSSValueRepeatingRadialGradient
         || id == CSSValueWebkitLinearGradient || id == CSSValueWebkitRadialGradient
         || id == CSSValueWebkitRepeatingLinearGradient || id == CSSValueWebkitRepeatingRadialGradient
-        || id == CSSValueWebkitGradient || id == CSSValueWebkitCrossFade || id == CSSValuePaint;
+        || id == CSSValueWebkitGradient || id == CSSValueWebkitCrossFade || id == CSSValuePaint
+        || id == CSSValueConicGradient || id == CSSValueRepeatingConicGradient;
 }
 
 static CSSValue* consumeImage(CSSParserTokenRange& range, CSSParserContext context)
 {
     AtomicString uri(consumeUrl(range));
     if (!uri.isNull())
         return createCSSImageValueWithReferrer(uri, context);
     if (range.peek().type() == FunctionToken) {
         CSSValueID id = range.peek().functionId();
         if (id == CSSValueWebkitImageSet)
@@ skipping 2656 matching lines @@
         return consumeGridTemplateShorthand(important);
     case CSSPropertyGrid:
         return consumeGridShorthand(important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink