Conic gradient parsing support

third_party/WebKit/Source/core/css/CSSGradientValue.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 26 matching lines @@
 class Color;
 class FloatPoint;
 class Gradient;
 
 enum CSSGradientType {
   CSSDeprecatedLinearGradient,
   CSSDeprecatedRadialGradient,
   CSSPrefixedLinearGradient,
   CSSPrefixedRadialGradient,
   CSSLinearGradient,
-  CSSRadialGradient
+  CSSRadialGradient,
+  CSSConicGradient
 };
 enum CSSGradientRepeat { NonRepeating, Repeating };
 
 // This struct is stack allocated and allocated as part of vectors.
 // When allocated on the stack its members are found by conservative
 // stack scanning. When allocated as part of Vectors in heap-allocated
 // objects its members are visited via the containing object's
 // (CSSGradientValue) traceAfterDispatch method.
 //
 // http://www.w3.org/TR/css3-images/#color-stop-syntax
 struct CSSGradientColorStop {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   CSSGradientColorStop() : m_colorIsDerivedFromElement(false) {}
-  Member<CSSPrimitiveValue> m_position;  // percentage or length
+  Member<CSSPrimitiveValue> m_position;  // percentage | length | angle

[fs, 2017/03/28 15:59:20]

(I sense that "m_offsetValue" or somesuch might be a better, more general, term
here, but we can leave that to the cleanup I suppose.)

[f(malita), 2017/03/28 17:16:45]

Ack, that would touch a bunch of code.

   Member<CSSValue> m_color;
   bool m_colorIsDerivedFromElement;
   bool operator==(const CSSGradientColorStop& other) const {
     return dataEquivalent(m_color, other.m_color) &&
            dataEquivalent(m_position, other.m_position);
   }
   bool isHint() const {
     ASSERT(m_color || m_position);
     return !m_color;
   }
@@ skipping 15 matching lines @@
 
   void setFirstX(CSSValue* val) { m_firstX = val; }
   void setFirstY(CSSValue* val) { m_firstY = val; }
   void setSecondX(CSSValue* val) { m_secondX = val; }
   void setSecondY(CSSValue* val) { m_secondY = val; }
 
   void addStop(const CSSGradientColorStop& stop) { m_stops.push_back(stop); }
 
   unsigned stopCount() const { return m_stops.size(); }
 
-  void appendCSSTextForDeprecatedColorStops(StringBuilder&) const;
-
   bool isRepeating() const { return m_repeating; }
 
   CSSGradientType gradientType() const { return m_gradientType; }
 
   bool isFixedSize() const { return false; }
   IntSize fixedSize(const LayoutObject&) const { return IntSize(); }
 
   bool isPending() const { return false; }
   bool knownToBeOpaque(const LayoutObject&) const;
 
@@ skipping 20 matching lines @@
   void addDeprecatedStops(GradientDesc&, const LayoutObject&);
 
   // Resolve points/radii to front end values.
   FloatPoint computeEndPoint(CSSValue*,
                              CSSValue*,
                              const CSSToLengthConversionData&,
                              const IntSize&);
 
   bool isCacheable() const;
 
+  void appendCSSTextForColorStops(StringBuilder&, bool requiresSeparator) const;
+  void appendCSSTextForDeprecatedColorStops(StringBuilder&) const;
+
   // Points. Some of these may be null.
   Member<CSSValue> m_firstX;
   Member<CSSValue> m_firstY;
 
   Member<CSSValue> m_secondX;
   Member<CSSValue> m_secondY;
 
   // Stops
   HeapVector<CSSGradientColorStop, 2> m_stops;
   bool m_stopsSorted;
@@ skipping 82 matching lines @@
   // null.
   Member<CSSIdentifierValue> m_shape;
   Member<CSSIdentifierValue> m_sizingBehavior;
 
   Member<CSSPrimitiveValue> m_endHorizontalSize;
   Member<CSSPrimitiveValue> m_endVerticalSize;
 };
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSRadialGradientValue, isRadialGradientValue());
 
+class CSSConicGradientValue final : public CSSGradientValue {
+ public:
+  static CSSConicGradientValue* create(CSSGradientRepeat repeat) {
+    return new CSSConicGradientValue(repeat);
+  }
+
+  String customCSSText() const;
+
+  // Create the gradient for a given size.
+  PassRefPtr<Gradient> createGradient(const CSSToLengthConversionData&,
+                                      const IntSize&,
+                                      const LayoutObject&);
+
+  void setFromAngle(CSSPrimitiveValue* val) { m_fromAngle = val; }
+
+  bool equals(const CSSConicGradientValue&) const;
+
+  DECLARE_TRACE_AFTER_DISPATCH();
+
+ private:
+  CSSConicGradientValue(CSSGradientRepeat repeat)
+      : CSSGradientValue(ConicGradientClass, repeat, CSSConicGradient) {}
+
+  Member<CSSPrimitiveValue> m_fromAngle;
+};
+
+DEFINE_CSS_VALUE_TYPE_CASTS(CSSConicGradientValue, isConicGradientValue());
+
 }  // namespace blink
 
 #endif  // CSSGradientValue_h