Support radial-gradients with relative offsets

Source/core/css/CSSGradientValue.cpp

 /*
  * 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 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/css/CSSGradientValue.h"
 
 #include "core/CSSValueKeywords.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSToLengthConversionData.h"
+#include "core/css/Pair.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/TextLinkColors.h"
 #include "core/rendering/RenderObject.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/GradientGeneratedImage.h"
 #include "platform/graphics/Image.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
@@ skipping 338 matching lines @@
 
             gradient->setStartRadius(gradient->startRadius() * scale);
             gradient->setEndRadius(gradient->endRadius() * scale);
         }
     }
 
     for (unsigned i = 0; i < numStops; i++)
         gradient->addColorStop(stops[i].offset, stops[i].color);
 }
 
+static float positionFromPairValue(CSSPrimitiveValue* value, int edgeDistance, const CSSToLengthConversionData& conversionData)

[f(malita), 2014/06/26 20:33:43]

I think we can fold this into the original method, see below.

+{
+    if (value->isNumber())
+        return edgeDistance - (value->getFloatValue() * conversionData.zoom());
+    if (value->isPercentage())
+        return (100 - value->getFloatValue()) / 100.f * edgeDistance;
+    if (value->isCalculatedPercentageWithLength())
+        return edgeDistance - value->cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);
+    return edgeDistance - value->computeLength<float>(conversionData);
+}
+
 static float positionFromValue(CSSPrimitiveValue* value, const CSSToLengthConversionData& conversionData, const IntSize& size, bool isHorizontal)

[f(malita), 2014/06/26 20:33:43]

How about something like this instead:

static float positionFromValue(CSSPrimitiveValue* value, const
CSSToLengthConversionData& conversionData, const IntSize& size, bool
isHorizontal)
{
    int origin = 0;
    int sign = 1;
    int edgeDistance = isHorizontal ? size.width() : size.height();

    if (Pair* pair = value->getPairValue()) {
        CSSValueID originID = pair->first()->getValueID();
        value = pair->second();

        if (originID == CSSValueRight || originID == CSSValueBottom) {
            // For right/bottom, the offset is relative to the far edge.
            origin = edgeDistance;
            sign = -1;
        }
    }

    if (value->isNumber())
        return origin + sign * value->getFloatValue() * conversionData.zoom();

    if (value->isPercentage())
        return origin + sign * value->getFloatValue() / 100.f * edgeDistance;

    if (value->isCalculatedPercentageWithLength())
        return origin + sign *
value->cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);

    switch (value->getValueID()) {
        ... // same as before
    }

    return origin + sign * value->computeLength<float>(conversionData);
}

 {
+    int edgeDistance = isHorizontal ? size.width() : size.height();
+    if (Pair* pair = value->getPairValue()) {

[f(malita), 2014/06/26 20:33:42]

We should probably add an inline comment describing the type of CSS gradient
syntax covered by this branch.

+        CSSValueID keyword = pair->first()->getValueID();
+        CSSPrimitiveValue* offsetValue = pair->second();
+
+        if (keyword == CSSValueRight || keyword == CSSValueBottom)
+            return positionFromPairValue(offsetValue, edgeDistance, conversionData);
+
+        value = offsetValue;
+    }
+
     if (value->isNumber())
         return value->getFloatValue() * conversionData.zoom();
 
-    int edgeDistance = isHorizontal ? size.width() : size.height();
     if (value->isPercentage())
         return value->getFloatValue() / 100.f * edgeDistance;
 
     if (value->isCalculatedPercentageWithLength())
         return value->cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);
 
     switch (value->getValueID()) {
     case CSSValueTop:
         ASSERT(!isHorizontal);
         return 0;
@@ skipping 775 matching lines @@
     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);
 }
 
 } // namespace WebCore