Conic gradient parsing support

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

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 Google 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
@@ skipping 43 matching lines @@
   switch (valueID) {
     case CSSValueInternalQuirkInherit:
     case CSSValueWebkitLink:
     case CSSValueWebkitActivelink:
     case CSSValueCurrentcolor:
       return true;
     default:
       return false;
   }
 }
+
+bool appendPosition(StringBuilder& result,
+                    const CSSValue* x,
+                    const CSSValue* y,
+                    bool wroteSomething) {
+  if (!x && !y)
+    return false;
+
+  if (wroteSomething)
+    result.append(' ');
+  result.append("at ");
+
+  if (x) {
+    result.append(x->cssText());
+    if (y)
+      result.append(' ');
+  }
+
+  if (y)
+    result.append(y->cssText());
+
+  return true;
+}
 }
 
 DEFINE_TRACE(CSSGradientColorStop) {
   visitor->trace(m_position);
   visitor->trace(m_color);
 }
 
 PassRefPtr<Image> CSSGradientValue::image(const LayoutObject& layoutObject,
                                           const IntSize& size) {
   if (size.isEmpty())
@@ skipping 12 matching lines @@
   }
 
   // We need to create an image.
   RefPtr<Gradient> gradient;
 
   const ComputedStyle* rootStyle =
       layoutObject.document().documentElement()->computedStyle();
   CSSToLengthConversionData conversionData(
       layoutObject.style(), rootStyle, LayoutViewItem(layoutObject.view()),
       layoutObject.style()->effectiveZoom());
-  if (isLinearGradientValue())
-    gradient = toCSSLinearGradientValue(this)->createGradient(
-        conversionData, size, layoutObject);
-  else
-    gradient = toCSSRadialGradientValue(this)->createGradient(
-        conversionData, size, layoutObject);
+
+  switch (getClassType()) {
+    case LinearGradientClass:
+      gradient = toCSSLinearGradientValue(this)->createGradient(
+          conversionData, size, layoutObject);
+      break;
+    case RadialGradientClass:
+      gradient = toCSSRadialGradientValue(this)->createGradient(
+          conversionData, size, layoutObject);
+      break;
+    case ConicGradientClass:
+      gradient = toCSSConicGradientValue(this)->createGradient(
+          conversionData, size, layoutObject);
+      break;
+    default:
+      NOTREACHED();
+  }
 
   RefPtr<Image> newImage = GradientGeneratedImage::create(gradient, size);
   if (cacheable)
     putImage(size, newImage);
 
   return newImage.release();
 }
 
 // Should only ever be called for deprecated gradients.
 static inline bool compareStops(const CSSGradientColorStop& a,
@@ skipping 328 matching lines @@
       else if (stop.m_position->isLength() ||
                stop.m_position->isCalculatedPercentageWithLength()) {
         float length;
         if (stop.m_position->isLength())
           length = stop.m_position->computeLength<float>(conversionData);
         else
           length = stop.m_position->cssCalcValue()
                        ->toCalcValue(conversionData)
                        ->evaluate(gradientLength);
         stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
+      } else if (stop.m_position->isAngle()) {
+        stops[i].offset = stop.m_position->computeDegrees() / 360.0f;
       } else {
         ASSERT_NOT_REACHED();
         stops[i].offset = 0;
       }
       stops[i].specified = true;
     } else {
       // If the first color-stop does not have a position, its position defaults
       // to 0%. If the last color-stop does not have a position, its position
       // defaults to 100%.
       if (!i) {
@@ skipping 272 matching lines @@
         result.append(m_firstX->cssText());
         result.append(' ');
         result.append(m_firstY->cssText());
       } else if (m_firstX)
         result.append(m_firstX->cssText());
       else
         result.append(m_firstY->cssText());
       wroteSomething = true;
     }
 
-    if (wroteSomething)
-      result.append(", ");
-
-    for (unsigned i = 0; i < m_stops.size(); i++) {
-      const CSSGradientColorStop& stop = m_stops[i];
-      if (i)
-        result.append(", ");
-      if (stop.m_color)
-        result.append(stop.m_color->cssText());
-      if (stop.m_color && stop.m_position)
-        result.append(' ');
-      if (stop.m_position)
-        result.append(stop.m_position->cssText());
-    }
+    appendCSSTextForColorStops(result, wroteSomething);
   }
 
   result.append(')');
   return result.toString();
 }
 
 // Compute the endpoints so that a gradient of the given angle covers a box of
 // the given size.
 static void endPointsFromAngle(float angleDeg,
                                const IntSize& size,
@@ skipping 177 matching lines @@
   }
 
   return equalXandY && m_stops == other.m_stops;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSLinearGradientValue) {
   visitor->trace(m_angle);
   CSSGradientValue::traceAfterDispatch(visitor);
 }
 
-inline void CSSGradientValue::appendCSSTextForDeprecatedColorStops(
+void CSSGradientValue::appendCSSTextForColorStops(
+    StringBuilder& result,
+    bool requiresSeparator) const {
+  if (requiresSeparator)
+    result.append(", ");
+
+  for (unsigned i = 0; i < m_stops.size(); i++) {
+    const CSSGradientColorStop& stop = m_stops[i];
+    if (i)
+      result.append(", ");
+    if (stop.m_color)
+      result.append(stop.m_color->cssText());
+    if (stop.m_color && stop.m_position)
+      result.append(' ');
+    if (stop.m_position)
+      result.append(stop.m_position->cssText());
+  }
+}
+
+void CSSGradientValue::appendCSSTextForDeprecatedColorStops(
     StringBuilder& result) const {
   for (unsigned i = 0; i < m_stops.size(); i++) {
     const CSSGradientColorStop& stop = m_stops[i];
     result.append(", ");
     if (stop.m_position->getDoubleValue() == 0) {
       result.append("from(");
       result.append(stop.m_color->cssText());
       result.append(')');
     } else if (stop.m_position->getDoubleValue() == 1) {
       result.append("to(");
@@ skipping 99 matching lines @@
       if (wroteSomething)
         result.append(' ');
       result.append(m_endHorizontalSize->cssText());
       if (m_endVerticalSize) {
         result.append(' ');
         result.append(m_endVerticalSize->cssText());
       }
       wroteSomething = true;
     }
 
-    if (m_firstX || m_firstY) {
-      if (wroteSomething)
-        result.append(' ');
-      result.append("at ");
-      if (m_firstX && m_firstY) {
-        result.append(m_firstX->cssText());
-        result.append(' ');
-        result.append(m_firstY->cssText());
-      } else if (m_firstX)
-        result.append(m_firstX->cssText());
-      else
-        result.append(m_firstY->cssText());
-      wroteSomething = true;
-    }
+    wroteSomething |=
+        appendPosition(result, m_firstX, m_firstY, wroteSomething);
 
-    if (wroteSomething)
-      result.append(", ");
-
-    for (unsigned i = 0; i < m_stops.size(); i++) {
-      const CSSGradientColorStop& stop = m_stops[i];
-      if (i)
-        result.append(", ");
-      if (stop.m_color)
-        result.append(stop.m_color->cssText());
-      if (stop.m_color && stop.m_position)
-        result.append(' ');
-      if (stop.m_position)
-        result.append(stop.m_position->cssText());
-    }
+    appendCSSTextForColorStops(result, wroteSomething);
   }
 
   result.append(')');
   return result.toString();
 }
 
 float CSSRadialGradientValue::resolveRadius(
     CSSPrimitiveValue* radius,
     const CSSToLengthConversionData& conversionData,
     float* widthOrHeight) {
@@ skipping 226 matching lines @@
 DEFINE_TRACE_AFTER_DISPATCH(CSSRadialGradientValue) {
   visitor->trace(m_firstRadius);
   visitor->trace(m_secondRadius);
   visitor->trace(m_shape);
   visitor->trace(m_sizingBehavior);
   visitor->trace(m_endHorizontalSize);
   visitor->trace(m_endVerticalSize);
   CSSGradientValue::traceAfterDispatch(visitor);
 }
 
+String CSSConicGradientValue::customCSSText() const {
+  StringBuilder result;
+
+  if (m_repeating)
+    result.append("repeating-");
+  result.append("conic-gradient(");
+
+  bool wroteSomething = false;
+
+  if (m_fromAngle) {
+    result.append("from ");
+    result.append(m_fromAngle->cssText());
+    wroteSomething = true;
+  }
+
+  wroteSomething |= appendPosition(result, m_firstX, m_firstY, wroteSomething);
+
+  appendCSSTextForColorStops(result, wroteSomething);
+
+  result.append(')');
+  return result.toString();
+}
+
+PassRefPtr<Gradient> CSSConicGradientValue::createGradient(
+    const CSSToLengthConversionData& conversionData,
+    const IntSize& size,
+    const LayoutObject& object) {
+  DCHECK(!size.isEmpty());
+
+  // TODO(fmalita): implement
+  return Gradient::create(FloatPoint(), FloatPoint());
+}
+
+bool CSSConicGradientValue::equals(const CSSConicGradientValue& other) const {
+  return m_repeating == other.m_repeating &&
+         dataEquivalent(m_firstX, other.m_firstX) &&
+         dataEquivalent(m_firstY, other.m_firstY) &&
+         dataEquivalent(m_fromAngle, other.m_fromAngle) &&
+         m_stops == other.m_stops;
+}
+
+DEFINE_TRACE_AFTER_DISPATCH(CSSConicGradientValue) {
+  visitor->trace(m_fromAngle);
+  CSSGradientValue::traceAfterDispatch(visitor);
+}
+
 }  // namespace blink