Generate toCSSFooValue for CSS*GradientValues

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 43 matching lines @@
 
         // Need to look up our size.  Create a string of width*height to use as a hash key.
         Image* result = getImage(renderer, size);
         if (result)
             return result;
     }
 
     // We need to create an image.
     RefPtr<Gradient> gradient;
 
-    if (isLinearGradient())
-        gradient = static_cast<CSSLinearGradientValue*>(this)->createGradient(renderer, size);
+    if (isLinearGradientValue())
+        gradient = toCSSLinearGradientValue(this)->createGradient(renderer, size);
     else {
-        ASSERT(isRadialGradient());
-        gradient = static_cast<CSSRadialGradientValue*>(this)->createGradient(renderer, size);
+        ASSERT(isRadialGradientValue());

[tkent, 2013/09/30 23:54:37]

This assertion is redundant.

[gyuyoung-inactive, 2013/10/01 02:27:42]

Exactly right. I missed to remove it. Thx !

+        gradient = toCSSRadialGradientValue(this)->createGradient(renderer, size);
     }
 
     RefPtr<Image> newImage = GeneratorGeneratedImage::create(gradient, size);
     if (cacheable)
         putImage(size, newImage);
 
     return newImage.release();
 }
 
 // Should only ever be called for deprecated gradients.
@@ skipping 32 matching lines @@
     for (unsigned i = 0; i < m_stops.size(); i++)
         if (m_stops[i].m_color->colorIsDerivedFromElement()) {
             m_stops[i].m_colorIsDerivedFromElement = true;
             derived = true;
             break;
         }
 
     RefPtr<CSSGradientValue> result;
     if (!derived)
         result = this;
-    else if (isLinearGradient())
-        result = static_cast<CSSLinearGradientValue*>(this)->clone();
-    else if (isRadialGradient())
-        result = static_cast<CSSRadialGradientValue*>(this)->clone();
+    else if (isLinearGradientValue())
+        result = toCSSLinearGradientValue(this)->clone();
+    else if (isRadialGradientValue())
+        result = toCSSRadialGradientValue(this)->clone();
     else {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     for (unsigned i = 0; i < result->m_stops.size(); i++)
         result->m_stops[i].m_resolvedColor = textLinkColors.colorFromPrimitiveValue(result->m_stops[i].m_color.get(), currentColor);
 
     return result.release();
 }
@@ skipping 24 matching lines @@
 
     size_t numStops = m_stops.size();
 
     Vector<GradientStop> stops(numStops);
 
     float gradientLength = 0;
     bool computedGradientLength = false;
 
     FloatPoint gradientStart = gradient->p0();
     FloatPoint gradientEnd;
-    if (isLinearGradient())
+    if (isLinearGradientValue())
         gradientEnd = gradient->p1();
-    else if (isRadialGradient())
+    else if (isRadialGradientValue())
         gradientEnd = gradientStart + FloatSize(gradient->endRadius(), 0);
 
     for (size_t i = 0; i < numStops; ++i) {
         const CSSGradientColorStop& stop = m_stops[i];
 
         stops[i].color = stop.m_resolvedColor;
 
         if (stop.m_position) {
             if (stop.m_position->isPercentage())
                 stops[i].offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
@@ skipping 80 matching lines @@
         if (!gradientRange) {
             stops.first().offset = 0;
             stops.first().color = stops.last().color;
             stops.shrink(1);
             numStops = 1;
         } else {
             float maxExtent = 1;
 
             // Radial gradients may need to extend further than the endpoints, because they have
             // to repeat out to the corners of the box.
-            if (isRadialGradient()) {
+            if (isRadialGradientValue()) {
                 if (!computedGradientLength) {
                     FloatSize gradientSize(gradientStart - gradientEnd);
                     gradientLength = gradientSize.diagonalLength();
                 }
 
                 if (maxLengthForRepeat > gradientLength)
                     maxExtent = gradientLength > 0 ? maxLengthForRepeat / gradientLength : 0;
             }
 
             size_t originalNumStops = numStops;
@@ skipping 37 matching lines @@
                     srcStopOrdinal = (srcStopOrdinal + 1) % originalNumStops;
                 }
             }
         }
     }
 
     numStops = stops.size();
 
     // If the gradient goes outside the 0-1 range, normalize it by moving the endpoints, and adjusting the stops.
     if (numStops > 1 && (stops[0].offset < 0 || stops[numStops - 1].offset > 1)) {
-        if (isLinearGradient()) {
+        if (isLinearGradientValue()) {
             float firstOffset = stops[0].offset;
             float lastOffset = stops[numStops - 1].offset;
             float scale = lastOffset - firstOffset;
 
             for (size_t i = 0; i < numStops; ++i)
                 stops[i].offset = (stops[i].offset - firstOffset) / scale;
 
             FloatPoint p0 = gradient->p0();
             FloatPoint p1 = gradient->p1();
             gradient->setP0(FloatPoint(p0.x() + firstOffset * (p1.x() - p0.x()), p0.y() + firstOffset * (p1.y() - p0.y())));
             gradient->setP1(FloatPoint(p1.x() + (lastOffset - 1) * (p1.x() - p0.x()), p1.y() + (lastOffset - 1) * (p1.y() - p0.y())));
-        } else if (isRadialGradient()) {
+        } else if (isRadialGradientValue()) {
             // Rather than scaling the points < 0, we truncate them, so only scale according to the largest point.
             float firstOffset = 0;
             float lastOffset = stops[numStops - 1].offset;
             float scale = lastOffset - firstOffset;
 
             // Reset points below 0 to the first visible color.
             size_t firstZeroOrGreaterIndex = numStops;
             for (size_t i = 0; i < numStops; ++i) {
                 if (stops[i].offset >= 0) {
                     firstZeroOrGreaterIndex = i;
@@ skipping 811 matching lines @@
         equalHorizontalAndVerticalSize = compareCSSValuePtr(m_endHorizontalSize, other.m_endHorizontalSize) && compareCSSValuePtr(m_endVerticalSize, other.m_endVerticalSize);
     else {
         equalShape = !other.m_shape;
         equalSizingBehavior = !other.m_sizingBehavior;
         equalHorizontalAndVerticalSize = !other.m_endHorizontalSize && !other.m_endVerticalSize;
     }
     return equalShape && equalSizingBehavior && equalHorizontalAndVerticalSize && m_stops == other.m_stops;
 }
 
 } // namespace WebCore