Home | History | Annotate | Download | only in css 
      1 /*
      2  * Copyright (C) 2008 Apple Inc.  All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 #include "core/css/CSSGradientValue.h"
     28 
     29 #include "core/CSSValueKeywords.h"
     30 #include "core/css/CSSCalculationValue.h"
     31 #include "core/css/CSSToLengthConversionData.h"
     32 #include "core/css/Pair.h"
     33 #include "core/dom/NodeRenderStyle.h"
     34 #include "core/dom/TextLinkColors.h"
     35 #include "core/rendering/RenderObject.h"
     36 #include "platform/geometry/IntSize.h"
     37 #include "platform/graphics/Gradient.h"
     38 #include "platform/graphics/GradientGeneratedImage.h"
     39 #include "platform/graphics/Image.h"
     40 #include "wtf/text/StringBuilder.h"
     41 #include "wtf/text/WTFString.h"
     42 
     43 namespace blink {
     44 
     45 void CSSGradientColorStop::trace(Visitor* visitor)
     46 {
     47     visitor->trace(m_position);
     48     visitor->trace(m_color);
     49 }
     50 
     51 PassRefPtr<Image> CSSGradientValue::image(RenderObject* renderer, const IntSize& size)
     52 {
     53     if (size.isEmpty())
     54         return nullptr;
     55 
     56     bool cacheable = isCacheable();
     57     if (cacheable) {
     58         if (!clients().contains(renderer))
     59             return nullptr;
     60 
     61         // Need to look up our size.  Create a string of width*height to use as a hash key.
     62         Image* result = getImage(renderer, size);
     63         if (result)
     64             return result;
     65     }
     66 
     67     // We need to create an image.
     68     RefPtr<Gradient> gradient;
     69 
     70     RenderStyle* rootStyle = renderer->document().documentElement()->renderStyle();
     71     CSSToLengthConversionData conversionData(renderer->style(), rootStyle, renderer->view());
     72     if (isLinearGradientValue())
     73         gradient = toCSSLinearGradientValue(this)->createGradient(conversionData, size);
     74     else
     75         gradient = toCSSRadialGradientValue(this)->createGradient(conversionData, size);
     76 
     77     RefPtr<Image> newImage = GradientGeneratedImage::create(gradient, size);
     78     if (cacheable)
     79         putImage(size, newImage);
     80 
     81     return newImage.release();
     82 }
     83 
     84 // Should only ever be called for deprecated gradients.
     85 static inline bool compareStops(const CSSGradientColorStop& a, const CSSGradientColorStop& b)
     86 {
     87     double aVal = a.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
     88     double bVal = b.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
     89 
     90     return aVal < bVal;
     91 }
     92 
     93 void CSSGradientValue::sortStopsIfNeeded()
     94 {
     95     ASSERT(m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient);
     96     if (!m_stopsSorted) {
     97         if (m_stops.size())
     98             std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
     99         m_stopsSorted = true;
    100     }
    101 }
    102 
    103 struct GradientStop {
    104     Color color;
    105     float offset;
    106     bool specified;
    107 
    108     GradientStop()
    109         : offset(0)
    110         , specified(false)
    111     { }
    112 };
    113 
    114 PassRefPtrWillBeRawPtr<CSSGradientValue> CSSGradientValue::gradientWithStylesResolved(const TextLinkColors& textLinkColors, Color currentColor)
    115 {
    116     bool derived = false;
    117     for (unsigned i = 0; i < m_stops.size(); i++)
    118         if (m_stops[i].m_color->colorIsDerivedFromElement()) {
    119             m_stops[i].m_colorIsDerivedFromElement = true;
    120             derived = true;
    121             break;
    122         }
    123 
    124     RefPtrWillBeRawPtr<CSSGradientValue> result = nullptr;
    125     if (!derived)
    126         result = this;
    127     else if (isLinearGradientValue())
    128         result = toCSSLinearGradientValue(this)->clone();
    129     else if (isRadialGradientValue())
    130         result = toCSSRadialGradientValue(this)->clone();
    131     else {
    132         ASSERT_NOT_REACHED();
    133         return nullptr;
    134     }
    135 
    136     for (unsigned i = 0; i < result->m_stops.size(); i++)
    137         result->m_stops[i].m_resolvedColor = textLinkColors.colorFromPrimitiveValue(result->m_stops[i].m_color.get(), currentColor);
    138 
    139     return result.release();
    140 }
    141 
    142 void CSSGradientValue::addStops(Gradient* gradient, const CSSToLengthConversionData& conversionData, float maxLengthForRepeat)
    143 {
    144     if (m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient) {
    145         sortStopsIfNeeded();
    146 
    147         for (unsigned i = 0; i < m_stops.size(); i++) {
    148             const CSSGradientColorStop& stop = m_stops[i];
    149 
    150             float offset;
    151             if (stop.m_position->isPercentage())
    152                 offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
    153             else
    154                 offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_NUMBER);
    155 
    156             gradient->addColorStop(offset, stop.m_resolvedColor);
    157         }
    158 
    159         return;
    160     }
    161 
    162     size_t numStops = m_stops.size();
    163 
    164     Vector<GradientStop> stops(numStops);
    165 
    166     float gradientLength = 0;
    167     bool computedGradientLength = false;
    168 
    169     FloatPoint gradientStart = gradient->p0();
    170     FloatPoint gradientEnd;
    171     if (isLinearGradientValue())
    172         gradientEnd = gradient->p1();
    173     else if (isRadialGradientValue())
    174         gradientEnd = gradientStart + FloatSize(gradient->endRadius(), 0);
    175 
    176     for (size_t i = 0; i < numStops; ++i) {
    177         const CSSGradientColorStop& stop = m_stops[i];
    178 
    179         stops[i].color = stop.m_resolvedColor;
    180 
    181         if (stop.m_position) {
    182             if (stop.m_position->isPercentage())
    183                 stops[i].offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
    184             else if (stop.m_position->isLength() || stop.m_position->isCalculatedPercentageWithLength()) {
    185                 if (!computedGradientLength) {
    186                     FloatSize gradientSize(gradientStart - gradientEnd);
    187                     gradientLength = gradientSize.diagonalLength();
    188                 }
    189                 float length;
    190                 if (stop.m_position->isLength())
    191                     length = stop.m_position->computeLength<float>(conversionData);
    192                 else
    193                     length = stop.m_position->cssCalcValue()->toCalcValue(conversionData)->evaluate(gradientLength);
    194                 stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
    195             } else {
    196                 ASSERT_NOT_REACHED();
    197                 stops[i].offset = 0;
    198             }
    199             stops[i].specified = true;
    200         } else {
    201             // If the first color-stop does not have a position, its position defaults to 0%.
    202             // If the last color-stop does not have a position, its position defaults to 100%.
    203             if (!i) {
    204                 stops[i].offset = 0;
    205                 stops[i].specified = true;
    206             } else if (numStops > 1 && i == numStops - 1) {
    207                 stops[i].offset = 1;
    208                 stops[i].specified = true;
    209             }
    210         }
    211 
    212         // If a color-stop has a position that is less than the specified position of any
    213         // color-stop before it in the list, its position is changed to be equal to the
    214         // largest specified position of any color-stop before it.
    215         if (stops[i].specified && i > 0) {
    216             size_t prevSpecifiedIndex;
    217             for (prevSpecifiedIndex = i - 1; prevSpecifiedIndex; --prevSpecifiedIndex) {
    218                 if (stops[prevSpecifiedIndex].specified)
    219                     break;
    220             }
    221 
    222             if (stops[i].offset < stops[prevSpecifiedIndex].offset)
    223                 stops[i].offset = stops[prevSpecifiedIndex].offset;
    224         }
    225     }
    226 
    227     ASSERT(stops[0].specified && stops[numStops - 1].specified);
    228 
    229     // If any color-stop still does not have a position, then, for each run of adjacent
    230     // color-stops without positions, set their positions so that they are evenly spaced
    231     // between the preceding and following color-stops with positions.
    232     if (numStops > 2) {
    233         size_t unspecifiedRunStart = 0;
    234         bool inUnspecifiedRun = false;
    235 
    236         for (size_t i = 0; i < numStops; ++i) {
    237             if (!stops[i].specified && !inUnspecifiedRun) {
    238                 unspecifiedRunStart = i;
    239                 inUnspecifiedRun = true;
    240             } else if (stops[i].specified && inUnspecifiedRun) {
    241                 size_t unspecifiedRunEnd = i;
    242 
    243                 if (unspecifiedRunStart < unspecifiedRunEnd) {
    244                     float lastSpecifiedOffset = stops[unspecifiedRunStart - 1].offset;
    245                     float nextSpecifiedOffset = stops[unspecifiedRunEnd].offset;
    246                     float delta = (nextSpecifiedOffset - lastSpecifiedOffset) / (unspecifiedRunEnd - unspecifiedRunStart + 1);
    247 
    248                     for (size_t j = unspecifiedRunStart; j < unspecifiedRunEnd; ++j)
    249                         stops[j].offset = lastSpecifiedOffset + (j - unspecifiedRunStart + 1) * delta;
    250                 }
    251 
    252                 inUnspecifiedRun = false;
    253             }
    254         }
    255     }
    256 
    257     // If the gradient is repeating, repeat the color stops.
    258     // We can't just push this logic down into the platform-specific Gradient code,
    259     // because we have to know the extent of the gradient, and possible move the end points.
    260     if (m_repeating && numStops > 1) {
    261         // If the difference in the positions of the first and last color-stops is 0,
    262         // the gradient defines a solid-color image with the color of the last color-stop in the rule.
    263         float gradientRange = stops[numStops - 1].offset - stops[0].offset;
    264         if (!gradientRange) {
    265             stops.first().offset = 0;
    266             stops.first().color = stops.last().color;
    267             stops.shrink(1);
    268         } else {
    269             float maxExtent = 1;
    270 
    271             // Radial gradients may need to extend further than the endpoints, because they have
    272             // to repeat out to the corners of the box.
    273             if (isRadialGradientValue()) {
    274                 if (!computedGradientLength) {
    275                     FloatSize gradientSize(gradientStart - gradientEnd);
    276                     gradientLength = gradientSize.diagonalLength();
    277                 }
    278 
    279                 if (maxLengthForRepeat > gradientLength)
    280                     maxExtent = gradientLength > 0 ? maxLengthForRepeat / gradientLength : 0;
    281             }
    282 
    283             size_t originalNumStops = numStops;
    284             size_t originalFirstStopIndex = 0;
    285 
    286             // Work backwards from the first, adding stops until we get one before 0.
    287             float firstOffset = stops[0].offset;
    288             if (firstOffset > 0) {
    289                 float currOffset = firstOffset;
    290                 size_t srcStopOrdinal = originalNumStops - 1;
    291 
    292                 while (true) {
    293                     GradientStop newStop = stops[originalFirstStopIndex + srcStopOrdinal];
    294                     newStop.offset = currOffset;
    295                     stops.prepend(newStop);
    296                     ++originalFirstStopIndex;
    297                     if (currOffset < 0)
    298                         break;
    299 
    300                     if (srcStopOrdinal)
    301                         currOffset -= stops[originalFirstStopIndex + srcStopOrdinal].offset - stops[originalFirstStopIndex + srcStopOrdinal - 1].offset;
    302                     srcStopOrdinal = (srcStopOrdinal + originalNumStops - 1) % originalNumStops;
    303                 }
    304             }
    305 
    306             // Work forwards from the end, adding stops until we get one after 1.
    307             float lastOffset = stops[stops.size() - 1].offset;
    308             if (lastOffset < maxExtent) {
    309                 float currOffset = lastOffset;
    310                 size_t srcStopOrdinal = 0;
    311 
    312                 while (true) {
    313                     size_t srcStopIndex = originalFirstStopIndex + srcStopOrdinal;
    314                     GradientStop newStop = stops[srcStopIndex];
    315                     newStop.offset = currOffset;
    316                     stops.append(newStop);
    317                     if (currOffset > maxExtent)
    318                         break;
    319                     if (srcStopOrdinal < originalNumStops - 1)
    320                         currOffset += stops[srcStopIndex + 1].offset - stops[srcStopIndex].offset;
    321                     srcStopOrdinal = (srcStopOrdinal + 1) % originalNumStops;
    322                 }
    323             }
    324         }
    325     }
    326 
    327     numStops = stops.size();
    328 
    329     // If the gradient goes outside the 0-1 range, normalize it by moving the endpoints, and adjusting the stops.
    330     if (numStops > 1 && (stops[0].offset < 0 || stops[numStops - 1].offset > 1)) {
    331         if (isLinearGradientValue()) {
    332             float firstOffset = stops[0].offset;
    333             float lastOffset = stops[numStops - 1].offset;
    334             float scale = lastOffset - firstOffset;
    335 
    336             for (size_t i = 0; i < numStops; ++i)
    337                 stops[i].offset = (stops[i].offset - firstOffset) / scale;
    338 
    339             FloatPoint p0 = gradient->p0();
    340             FloatPoint p1 = gradient->p1();
    341             gradient->setP0(FloatPoint(p0.x() + firstOffset * (p1.x() - p0.x()), p0.y() + firstOffset * (p1.y() - p0.y())));
    342             gradient->setP1(FloatPoint(p1.x() + (lastOffset - 1) * (p1.x() - p0.x()), p1.y() + (lastOffset - 1) * (p1.y() - p0.y())));
    343         } else if (isRadialGradientValue()) {
    344             // Rather than scaling the points < 0, we truncate them, so only scale according to the largest point.
    345             float firstOffset = 0;
    346             float lastOffset = stops[numStops - 1].offset;
    347             float scale = lastOffset - firstOffset;
    348 
    349             // Reset points below 0 to the first visible color.
    350             size_t firstZeroOrGreaterIndex = numStops;
    351             for (size_t i = 0; i < numStops; ++i) {
    352                 if (stops[i].offset >= 0) {
    353                     firstZeroOrGreaterIndex = i;
    354                     break;
    355                 }
    356             }
    357 
    358             if (firstZeroOrGreaterIndex > 0) {
    359                 if (firstZeroOrGreaterIndex < numStops && stops[firstZeroOrGreaterIndex].offset > 0) {
    360                     float prevOffset = stops[firstZeroOrGreaterIndex - 1].offset;
    361                     float nextOffset = stops[firstZeroOrGreaterIndex].offset;
    362 
    363                     float interStopProportion = -prevOffset / (nextOffset - prevOffset);
    364                     // FIXME: when we interpolate gradients using premultiplied colors, this should do premultiplication.
    365                     Color blendedColor = blend(stops[firstZeroOrGreaterIndex - 1].color, stops[firstZeroOrGreaterIndex].color, interStopProportion);
    366 
    367                     // Clamp the positions to 0 and set the color.
    368                     for (size_t i = 0; i < firstZeroOrGreaterIndex; ++i) {
    369                         stops[i].offset = 0;
    370                         stops[i].color = blendedColor;
    371                     }
    372                 } else {
    373                     // All stops are below 0; just clamp them.
    374                     for (size_t i = 0; i < firstZeroOrGreaterIndex; ++i)
    375                         stops[i].offset = 0;
    376                 }
    377             }
    378 
    379             for (size_t i = 0; i < numStops; ++i)
    380                 stops[i].offset /= scale;
    381 
    382             gradient->setStartRadius(gradient->startRadius() * scale);
    383             gradient->setEndRadius(gradient->endRadius() * scale);
    384         }
    385     }
    386 
    387     for (unsigned i = 0; i < numStops; i++)
    388         gradient->addColorStop(stops[i].offset, stops[i].color);
    389 }
    390 
    391 static float positionFromValue(CSSPrimitiveValue* value, const CSSToLengthConversionData& conversionData, const IntSize& size, bool isHorizontal)
    392 {
    393     int origin = 0;
    394     int sign = 1;
    395     int edgeDistance = isHorizontal ? size.width() : size.height();
    396 
    397     // In this case the center of the gradient is given relative to an edge in the form of:
    398     // [ top | bottom | right | left ] [ <percentage> | <length> ].
    399     if (Pair* pair = value->getPairValue()) {
    400         CSSValueID originID = pair->first()->getValueID();
    401         value = pair->second();
    402 
    403         if (originID == CSSValueRight || originID == CSSValueBottom) {
    404             // For right/bottom, the offset is relative to the far edge.
    405             origin = edgeDistance;
    406             sign = -1;
    407         }
    408     }
    409 
    410     if (value->isNumber())
    411         return origin + sign * value->getFloatValue() * conversionData.zoom();
    412 
    413     if (value->isPercentage())
    414         return origin + sign * value->getFloatValue() / 100.f * edgeDistance;
    415 
    416     if (value->isCalculatedPercentageWithLength())
    417         return origin + sign * value->cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);
    418 
    419     switch (value->getValueID()) {
    420     case CSSValueTop:
    421         ASSERT(!isHorizontal);
    422         return 0;
    423     case CSSValueLeft:
    424         ASSERT(isHorizontal);
    425         return 0;
    426     case CSSValueBottom:
    427         ASSERT(!isHorizontal);
    428         return size.height();
    429     case CSSValueRight:
    430         ASSERT(isHorizontal);
    431         return size.width();
    432     default:
    433         break;
    434     }
    435 
    436     return origin + sign * value->computeLength<float>(conversionData);
    437 }
    438 
    439 FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, const CSSToLengthConversionData& conversionData, const IntSize& size)
    440 {
    441     FloatPoint result;
    442 
    443     if (horizontal)
    444         result.setX(positionFromValue(horizontal, conversionData, size, true));
    445 
    446     if (vertical)
    447         result.setY(positionFromValue(vertical, conversionData, size, false));
    448 
    449     return result;
    450 }
    451 
    452 bool CSSGradientValue::isCacheable() const
    453 {
    454     for (size_t i = 0; i < m_stops.size(); ++i) {
    455         const CSSGradientColorStop& stop = m_stops[i];
    456 
    457         if (stop.m_colorIsDerivedFromElement)
    458             return false;
    459 
    460         if (!stop.m_position)
    461             continue;
    462 
    463         if (stop.m_position->isFontRelativeLength())
    464             return false;
    465     }
    466 
    467     return true;
    468 }
    469 
    470 bool CSSGradientValue::knownToBeOpaque(const RenderObject*) const
    471 {
    472     for (size_t i = 0; i < m_stops.size(); ++i) {
    473         if (m_stops[i].m_resolvedColor.hasAlpha())
    474             return false;
    475     }
    476     return true;
    477 }
    478 
    479 void CSSGradientValue::traceAfterDispatch(Visitor* visitor)
    480 {
    481     visitor->trace(m_firstX);
    482     visitor->trace(m_firstY);
    483     visitor->trace(m_secondX);
    484     visitor->trace(m_secondY);
    485     visitor->trace(m_stops);
    486     CSSImageGeneratorValue::traceAfterDispatch(visitor);
    487 }
    488 
    489 String CSSLinearGradientValue::customCSSText() const
    490 {
    491     StringBuilder result;
    492     if (m_gradientType == CSSDeprecatedLinearGradient) {
    493         result.appendLiteral("-webkit-gradient(linear, ");
    494         result.append(m_firstX->cssText());
    495         result.append(' ');
    496         result.append(m_firstY->cssText());
    497         result.appendLiteral(", ");
    498         result.append(m_secondX->cssText());
    499         result.append(' ');
    500         result.append(m_secondY->cssText());
    501 
    502         for (unsigned i = 0; i < m_stops.size(); i++) {
    503             const CSSGradientColorStop& stop = m_stops[i];
    504             result.appendLiteral(", ");
    505             if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 0) {
    506                 result.appendLiteral("from(");
    507                 result.append(stop.m_color->cssText());
    508                 result.append(')');
    509             } else if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 1) {
    510                 result.appendLiteral("to(");
    511                 result.append(stop.m_color->cssText());
    512                 result.append(')');
    513             } else {
    514                 result.appendLiteral("color-stop(");
    515                 result.appendNumber(stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER));
    516                 result.appendLiteral(", ");
    517                 result.append(stop.m_color->cssText());
    518                 result.append(')');
    519             }
    520         }
    521     } else if (m_gradientType == CSSPrefixedLinearGradient) {
    522         if (m_repeating)
    523             result.appendLiteral("-webkit-repeating-linear-gradient(");
    524         else
    525             result.appendLiteral("-webkit-linear-gradient(");
    526 
    527         if (m_angle)
    528             result.append(m_angle->cssText());
    529         else {
    530             if (m_firstX && m_firstY) {
    531                 result.append(m_firstX->cssText());
    532                 result.append(' ');
    533                 result.append(m_firstY->cssText());
    534             } else if (m_firstX || m_firstY) {
    535                 if (m_firstX)
    536                     result.append(m_firstX->cssText());
    537 
    538                 if (m_firstY)
    539                     result.append(m_firstY->cssText());
    540             }
    541         }
    542 
    543         for (unsigned i = 0; i < m_stops.size(); i++) {
    544             const CSSGradientColorStop& stop = m_stops[i];
    545             result.appendLiteral(", ");
    546             result.append(stop.m_color->cssText());
    547             if (stop.m_position) {
    548                 result.append(' ');
    549                 result.append(stop.m_position->cssText());
    550             }
    551         }
    552     } else {
    553         if (m_repeating)
    554             result.appendLiteral("repeating-linear-gradient(");
    555         else
    556             result.appendLiteral("linear-gradient(");
    557 
    558         bool wroteSomething = false;
    559 
    560         if (m_angle && m_angle->computeDegrees() != 180) {
    561             result.append(m_angle->cssText());
    562             wroteSomething = true;
    563         } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && m_firstY->getValueID() == CSSValueBottom)) {
    564             result.appendLiteral("to ");
    565             if (m_firstX && m_firstY) {
    566                 result.append(m_firstX->cssText());
    567                 result.append(' ');
    568                 result.append(m_firstY->cssText());
    569             } else if (m_firstX)
    570                 result.append(m_firstX->cssText());
    571             else
    572                 result.append(m_firstY->cssText());
    573             wroteSomething = true;
    574         }
    575 
    576         if (wroteSomething)
    577             result.appendLiteral(", ");
    578 
    579         for (unsigned i = 0; i < m_stops.size(); i++) {
    580             const CSSGradientColorStop& stop = m_stops[i];
    581             if (i)
    582                 result.appendLiteral(", ");
    583             result.append(stop.m_color->cssText());
    584             if (stop.m_position) {
    585                 result.append(' ');
    586                 result.append(stop.m_position->cssText());
    587             }
    588         }
    589 
    590     }
    591 
    592     result.append(')');
    593     return result.toString();
    594 }
    595 
    596 // Compute the endpoints so that a gradient of the given angle covers a box of the given size.
    597 static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint& firstPoint, FloatPoint& secondPoint, CSSGradientType type)
    598 {
    599     // Prefixed gradients use "polar coordinate" angles, rather than "bearing" angles.
    600     if (type == CSSPrefixedLinearGradient)
    601         angleDeg = 90 - angleDeg;
    602 
    603     angleDeg = fmodf(angleDeg, 360);
    604     if (angleDeg < 0)
    605         angleDeg += 360;
    606 
    607     if (!angleDeg) {
    608         firstPoint.set(0, size.height());
    609         secondPoint.set(0, 0);
    610         return;
    611     }
    612 
    613     if (angleDeg == 90) {
    614         firstPoint.set(0, 0);
    615         secondPoint.set(size.width(), 0);
    616         return;
    617     }
    618 
    619     if (angleDeg == 180) {
    620         firstPoint.set(0, 0);
    621         secondPoint.set(0, size.height());
    622         return;
    623     }
    624 
    625     if (angleDeg == 270) {
    626         firstPoint.set(size.width(), 0);
    627         secondPoint.set(0, 0);
    628         return;
    629     }
    630 
    631     // angleDeg is a "bearing angle" (0deg = N, 90deg = E),
    632     // but tan expects 0deg = E, 90deg = N.
    633     float slope = tan(deg2rad(90 - angleDeg));
    634 
    635     // We find the endpoint by computing the intersection of the line formed by the slope,
    636     // and a line perpendicular to it that intersects the corner.
    637     float perpendicularSlope = -1 / slope;
    638 
    639     // Compute start corner relative to center, in Cartesian space (+y = up).
    640     float halfHeight = size.height() / 2;
    641     float halfWidth = size.width() / 2;
    642     FloatPoint endCorner;
    643     if (angleDeg < 90)
    644         endCorner.set(halfWidth, halfHeight);
    645     else if (angleDeg < 180)
    646         endCorner.set(halfWidth, -halfHeight);
    647     else if (angleDeg < 270)
    648         endCorner.set(-halfWidth, -halfHeight);
    649     else
    650         endCorner.set(-halfWidth, halfHeight);
    651 
    652     // Compute c (of y = mx + c) using the corner point.
    653     float c = endCorner.y() - perpendicularSlope * endCorner.x();
    654     float endX = c / (slope - perpendicularSlope);
    655     float endY = perpendicularSlope * endX + c;
    656 
    657     // We computed the end point, so set the second point,
    658     // taking into account the moved origin and the fact that we're in drawing space (+y = down).
    659     secondPoint.set(halfWidth + endX, halfHeight - endY);
    660     // Reflect around the center for the start point.
    661     firstPoint.set(halfWidth - endX, halfHeight + endY);
    662 }
    663 
    664 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(const CSSToLengthConversionData& conversionData, const IntSize& size)
    665 {
    666     ASSERT(!size.isEmpty());
    667 
    668     FloatPoint firstPoint;
    669     FloatPoint secondPoint;
    670     if (m_angle) {
    671         float angle = m_angle->getFloatValue(CSSPrimitiveValue::CSS_DEG);
    672         endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
    673     } else {
    674         switch (m_gradientType) {
    675         case CSSDeprecatedLinearGradient:
    676             firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
    677             if (m_secondX || m_secondY)
    678                 secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
    679             else {
    680                 if (m_firstX)
    681                     secondPoint.setX(size.width() - firstPoint.x());
    682                 if (m_firstY)
    683                     secondPoint.setY(size.height() - firstPoint.y());
    684             }
    685             break;
    686         case CSSPrefixedLinearGradient:
    687             firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
    688             if (m_firstX)
    689                 secondPoint.setX(size.width() - firstPoint.x());
    690             if (m_firstY)
    691                 secondPoint.setY(size.height() - firstPoint.y());
    692             break;
    693         case CSSLinearGradient:
    694             if (m_firstX && m_firstY) {
    695                 // "Magic" corners, so the 50% line touches two corners.
    696                 float rise = size.width();
    697                 float run = size.height();
    698                 if (m_firstX && m_firstX->getValueID() == CSSValueLeft)
    699                     run *= -1;
    700                 if (m_firstY && m_firstY->getValueID() == CSSValueBottom)
    701                     rise *= -1;
    702                 // Compute angle, and flip it back to "bearing angle" degrees.
    703                 float angle = 90 - rad2deg(atan2(rise, run));
    704                 endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
    705             } else if (m_firstX || m_firstY) {
    706                 secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
    707                 if (m_firstX)
    708                     firstPoint.setX(size.width() - secondPoint.x());
    709                 if (m_firstY)
    710                     firstPoint.setY(size.height() - secondPoint.y());
    711             } else
    712                 secondPoint.setY(size.height());
    713             break;
    714         default:
    715             ASSERT_NOT_REACHED();
    716         }
    717 
    718     }
    719 
    720     RefPtr<Gradient> gradient = Gradient::create(firstPoint, secondPoint);
    721 
    722     gradient->setDrawsInPMColorSpace(true);
    723 
    724     // Now add the stops.
    725     addStops(gradient.get(), conversionData, 1);
    726 
    727     return gradient.release();
    728 }
    729 
    730 bool CSSLinearGradientValue::equals(const CSSLinearGradientValue& other) const
    731 {
    732     if (m_gradientType == CSSDeprecatedLinearGradient)
    733         return other.m_gradientType == m_gradientType
    734             && compareCSSValuePtr(m_firstX, other.m_firstX)
    735             && compareCSSValuePtr(m_firstY, other.m_firstY)
    736             && compareCSSValuePtr(m_secondX, other.m_secondX)
    737             && compareCSSValuePtr(m_secondY, other.m_secondY)
    738             && m_stops == other.m_stops;
    739 
    740     if (m_repeating != other.m_repeating)
    741         return false;
    742 
    743     if (m_angle)
    744         return compareCSSValuePtr(m_angle, other.m_angle) && m_stops == other.m_stops;
    745 
    746     if (other.m_angle)
    747         return false;
    748 
    749     bool equalXandY = false;
    750     if (m_firstX && m_firstY)
    751         equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && compareCSSValuePtr(m_firstY, other.m_firstY);
    752     else if (m_firstX)
    753         equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && !other.m_firstY;
    754     else if (m_firstY)
    755         equalXandY = compareCSSValuePtr(m_firstY, other.m_firstY) && !other.m_firstX;
    756     else
    757         equalXandY = !other.m_firstX && !other.m_firstY;
    758 
    759     return equalXandY && m_stops == other.m_stops;
    760 }
    761 
    762 void CSSLinearGradientValue::traceAfterDispatch(Visitor* visitor)
    763 {
    764     visitor->trace(m_angle);
    765     CSSGradientValue::traceAfterDispatch(visitor);
    766 }
    767 
    768 String CSSRadialGradientValue::customCSSText() const
    769 {
    770     StringBuilder result;
    771 
    772     if (m_gradientType == CSSDeprecatedRadialGradient) {
    773         result.appendLiteral("-webkit-gradient(radial, ");
    774         result.append(m_firstX->cssText());
    775         result.append(' ');
    776         result.append(m_firstY->cssText());
    777         result.appendLiteral(", ");
    778         result.append(m_firstRadius->cssText());
    779         result.appendLiteral(", ");
    780         result.append(m_secondX->cssText());
    781         result.append(' ');
    782         result.append(m_secondY->cssText());
    783         result.appendLiteral(", ");
    784         result.append(m_secondRadius->cssText());
    785 
    786         // FIXME: share?
    787         for (unsigned i = 0; i < m_stops.size(); i++) {
    788             const CSSGradientColorStop& stop = m_stops[i];
    789             result.appendLiteral(", ");
    790             if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 0) {
    791                 result.appendLiteral("from(");
    792                 result.append(stop.m_color->cssText());
    793                 result.append(')');
    794             } else if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 1) {
    795                 result.appendLiteral("to(");
    796                 result.append(stop.m_color->cssText());
    797                 result.append(')');
    798             } else {
    799                 result.appendLiteral("color-stop(");
    800                 result.appendNumber(stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER));
    801                 result.appendLiteral(", ");
    802                 result.append(stop.m_color->cssText());
    803                 result.append(')');
    804             }
    805         }
    806     } else if (m_gradientType == CSSPrefixedRadialGradient) {
    807         if (m_repeating)
    808             result.appendLiteral("-webkit-repeating-radial-gradient(");
    809         else
    810             result.appendLiteral("-webkit-radial-gradient(");
    811 
    812         if (m_firstX && m_firstY) {
    813             result.append(m_firstX->cssText());
    814             result.append(' ');
    815             result.append(m_firstY->cssText());
    816         } else if (m_firstX)
    817             result.append(m_firstX->cssText());
    818          else if (m_firstY)
    819             result.append(m_firstY->cssText());
    820         else
    821             result.appendLiteral("center");
    822 
    823         if (m_shape || m_sizingBehavior) {
    824             result.appendLiteral(", ");
    825             if (m_shape) {
    826                 result.append(m_shape->cssText());
    827                 result.append(' ');
    828             } else
    829                 result.appendLiteral("ellipse ");
    830 
    831             if (m_sizingBehavior)
    832                 result.append(m_sizingBehavior->cssText());
    833             else
    834                 result.appendLiteral("cover");
    835 
    836         } else if (m_endHorizontalSize && m_endVerticalSize) {
    837             result.appendLiteral(", ");
    838             result.append(m_endHorizontalSize->cssText());
    839             result.append(' ');
    840             result.append(m_endVerticalSize->cssText());
    841         }
    842 
    843         for (unsigned i = 0; i < m_stops.size(); i++) {
    844             const CSSGradientColorStop& stop = m_stops[i];
    845             result.appendLiteral(", ");
    846             result.append(stop.m_color->cssText());
    847             if (stop.m_position) {
    848                 result.append(' ');
    849                 result.append(stop.m_position->cssText());
    850             }
    851         }
    852     } else {
    853         if (m_repeating)
    854             result.appendLiteral("repeating-radial-gradient(");
    855         else
    856             result.appendLiteral("radial-gradient(");
    857 
    858         bool wroteSomething = false;
    859 
    860         // The only ambiguous case that needs an explicit shape to be provided
    861         // is when a sizing keyword is used (or all sizing is omitted).
    862         if (m_shape && m_shape->getValueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
    863             result.appendLiteral("circle");
    864             wroteSomething = true;
    865         }
    866 
    867         if (m_sizingBehavior && m_sizingBehavior->getValueID() != CSSValueFarthestCorner) {
    868             if (wroteSomething)
    869                 result.append(' ');
    870             result.append(m_sizingBehavior->cssText());
    871             wroteSomething = true;
    872         } else if (m_endHorizontalSize) {
    873             if (wroteSomething)
    874                 result.append(' ');
    875             result.append(m_endHorizontalSize->cssText());
    876             if (m_endVerticalSize) {
    877                 result.append(' ');
    878                 result.append(m_endVerticalSize->cssText());
    879             }
    880             wroteSomething = true;
    881         }
    882 
    883         if (m_firstX || m_firstY) {
    884             if (wroteSomething)
    885                 result.append(' ');
    886             result.appendLiteral("at ");
    887             if (m_firstX && m_firstY) {
    888                 result.append(m_firstX->cssText());
    889                 result.append(' ');
    890                 result.append(m_firstY->cssText());
    891             } else if (m_firstX)
    892                 result.append(m_firstX->cssText());
    893             else
    894                 result.append(m_firstY->cssText());
    895             wroteSomething = true;
    896         }
    897 
    898         if (wroteSomething)
    899             result.appendLiteral(", ");
    900 
    901         for (unsigned i = 0; i < m_stops.size(); i++) {
    902             const CSSGradientColorStop& stop = m_stops[i];
    903             if (i)
    904                 result.appendLiteral(", ");
    905             result.append(stop.m_color->cssText());
    906             if (stop.m_position) {
    907                 result.append(' ');
    908                 result.append(stop.m_position->cssText());
    909             }
    910         }
    911 
    912     }
    913 
    914     result.append(')');
    915     return result.toString();
    916 }
    917 
    918 float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, const CSSToLengthConversionData& conversionData, float* widthOrHeight)
    919 {
    920     float result = 0;
    921     if (radius->isNumber()) // Can the radius be a percentage?
    922         result = radius->getFloatValue() * conversionData.zoom();
    923     else if (widthOrHeight && radius->isPercentage())
    924         result = *widthOrHeight * radius->getFloatValue() / 100;
    925     else
    926         result = radius->computeLength<float>(conversionData);
    927 
    928     return result;
    929 }
    930 
    931 static float distanceToClosestCorner(const FloatPoint& p, const FloatSize& size, FloatPoint& corner)
    932 {
    933     FloatPoint topLeft;
    934     float topLeftDistance = FloatSize(p - topLeft).diagonalLength();
    935 
    936     FloatPoint topRight(size.width(), 0);
    937     float topRightDistance = FloatSize(p - topRight).diagonalLength();
    938 
    939     FloatPoint bottomLeft(0, size.height());
    940     float bottomLeftDistance = FloatSize(p - bottomLeft).diagonalLength();
    941 
    942     FloatPoint bottomRight(size.width(), size.height());
    943     float bottomRightDistance = FloatSize(p - bottomRight).diagonalLength();
    944 
    945     corner = topLeft;
    946     float minDistance = topLeftDistance;
    947     if (topRightDistance < minDistance) {
    948         minDistance = topRightDistance;
    949         corner = topRight;
    950     }
    951 
    952     if (bottomLeftDistance < minDistance) {
    953         minDistance = bottomLeftDistance;
    954         corner = bottomLeft;
    955     }
    956 
    957     if (bottomRightDistance < minDistance) {
    958         minDistance = bottomRightDistance;
    959         corner = bottomRight;
    960     }
    961     return minDistance;
    962 }
    963 
    964 static float distanceToFarthestCorner(const FloatPoint& p, const FloatSize& size, FloatPoint& corner)
    965 {
    966     FloatPoint topLeft;
    967     float topLeftDistance = FloatSize(p - topLeft).diagonalLength();
    968 
    969     FloatPoint topRight(size.width(), 0);
    970     float topRightDistance = FloatSize(p - topRight).diagonalLength();
    971 
    972     FloatPoint bottomLeft(0, size.height());
    973     float bottomLeftDistance = FloatSize(p - bottomLeft).diagonalLength();
    974 
    975     FloatPoint bottomRight(size.width(), size.height());
    976     float bottomRightDistance = FloatSize(p - bottomRight).diagonalLength();
    977 
    978     corner = topLeft;
    979     float maxDistance = topLeftDistance;
    980     if (topRightDistance > maxDistance) {
    981         maxDistance = topRightDistance;
    982         corner = topRight;
    983     }
    984 
    985     if (bottomLeftDistance > maxDistance) {
    986         maxDistance = bottomLeftDistance;
    987         corner = bottomLeft;
    988     }
    989 
    990     if (bottomRightDistance > maxDistance) {
    991         maxDistance = bottomRightDistance;
    992         corner = bottomRight;
    993     }
    994     return maxDistance;
    995 }
    996 
    997 // Compute horizontal radius of ellipse with center at 0,0 which passes through p, and has
    998 // width/height given by aspectRatio.
    999 static inline float horizontalEllipseRadius(const FloatSize& p, float aspectRatio)
   1000 {
   1001     // x^2/a^2 + y^2/b^2 = 1
   1002     // a/b = aspectRatio, b = a/aspectRatio
   1003     // a = sqrt(x^2 + y^2/(1/r^2))
   1004     return sqrtf(p.width() * p.width() + (p.height() * p.height()) / (1 / (aspectRatio * aspectRatio)));
   1005 }
   1006 
   1007 // FIXME: share code with the linear version
   1008 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(const CSSToLengthConversionData& conversionData, const IntSize& size)
   1009 {
   1010     ASSERT(!size.isEmpty());
   1011 
   1012     FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
   1013     if (!m_firstX)
   1014         firstPoint.setX(size.width() / 2);
   1015     if (!m_firstY)
   1016         firstPoint.setY(size.height() / 2);
   1017 
   1018     FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
   1019     if (!m_secondX)
   1020         secondPoint.setX(size.width() / 2);
   1021     if (!m_secondY)
   1022         secondPoint.setY(size.height() / 2);
   1023 
   1024     float firstRadius = 0;
   1025     if (m_firstRadius)
   1026         firstRadius = resolveRadius(m_firstRadius.get(), conversionData);
   1027 
   1028     float secondRadius = 0;
   1029     float aspectRatio = 1; // width / height.
   1030     if (m_secondRadius)
   1031         secondRadius = resolveRadius(m_secondRadius.get(), conversionData);
   1032     else if (m_endHorizontalSize) {
   1033         float width = size.width();
   1034         float height = size.height();
   1035         secondRadius = resolveRadius(m_endHorizontalSize.get(), conversionData, &width);
   1036         if (m_endVerticalSize)
   1037             aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), conversionData, &height);
   1038         else
   1039             aspectRatio = 1;
   1040     } else {
   1041         enum GradientShape { Circle, Ellipse };
   1042         GradientShape shape = Ellipse;
   1043         if ((m_shape && m_shape->getValueID() == CSSValueCircle)
   1044             || (!m_shape && !m_sizingBehavior && m_endHorizontalSize && !m_endVerticalSize))
   1045             shape = Circle;
   1046 
   1047         enum GradientFill { ClosestSide, ClosestCorner, FarthestSide, FarthestCorner };
   1048         GradientFill fill = FarthestCorner;
   1049 
   1050         switch (m_sizingBehavior ? m_sizingBehavior->getValueID() : 0) {
   1051         case CSSValueContain:
   1052         case CSSValueClosestSide:
   1053             fill = ClosestSide;
   1054             break;
   1055         case CSSValueClosestCorner:
   1056             fill = ClosestCorner;
   1057             break;
   1058         case CSSValueFarthestSide:
   1059             fill = FarthestSide;
   1060             break;
   1061         case CSSValueCover:
   1062         case CSSValueFarthestCorner:
   1063             fill = FarthestCorner;
   1064             break;
   1065         default:
   1066             break;
   1067         }
   1068 
   1069         // Now compute the end radii based on the second point, shape and fill.
   1070 
   1071         // Horizontal
   1072         switch (fill) {
   1073         case ClosestSide: {
   1074             float xDist = std::min(secondPoint.x(), size.width() - secondPoint.x());
   1075             float yDist = std::min(secondPoint.y(), size.height() - secondPoint.y());
   1076             if (shape == Circle) {
   1077                 float smaller = std::min(xDist, yDist);
   1078                 xDist = smaller;
   1079                 yDist = smaller;
   1080             }
   1081             secondRadius = xDist;
   1082             aspectRatio = xDist / yDist;
   1083             break;
   1084         }
   1085         case FarthestSide: {
   1086             float xDist = std::max(secondPoint.x(), size.width() - secondPoint.x());
   1087             float yDist = std::max(secondPoint.y(), size.height() - secondPoint.y());
   1088             if (shape == Circle) {
   1089                 float larger = std::max(xDist, yDist);
   1090                 xDist = larger;
   1091                 yDist = larger;
   1092             }
   1093             secondRadius = xDist;
   1094             aspectRatio = xDist / yDist;
   1095             break;
   1096         }
   1097         case ClosestCorner: {
   1098             FloatPoint corner;
   1099             float distance = distanceToClosestCorner(secondPoint, size, corner);
   1100             if (shape == Circle)
   1101                 secondRadius = distance;
   1102             else {
   1103                 // If <shape> is ellipse, the gradient-shape has the same ratio of width to height
   1104                 // that it would if closest-side or farthest-side were specified, as appropriate.
   1105                 float xDist = std::min(secondPoint.x(), size.width() - secondPoint.x());
   1106                 float yDist = std::min(secondPoint.y(), size.height() - secondPoint.y());
   1107 
   1108                 secondRadius = horizontalEllipseRadius(corner - secondPoint, xDist / yDist);
   1109                 aspectRatio = xDist / yDist;
   1110             }
   1111             break;
   1112         }
   1113 
   1114         case FarthestCorner: {
   1115             FloatPoint corner;
   1116             float distance = distanceToFarthestCorner(secondPoint, size, corner);
   1117             if (shape == Circle)
   1118                 secondRadius = distance;
   1119             else {
   1120                 // If <shape> is ellipse, the gradient-shape has the same ratio of width to height
   1121                 // that it would if closest-side or farthest-side were specified, as appropriate.
   1122                 float xDist = std::max(secondPoint.x(), size.width() - secondPoint.x());
   1123                 float yDist = std::max(secondPoint.y(), size.height() - secondPoint.y());
   1124 
   1125                 secondRadius = horizontalEllipseRadius(corner - secondPoint, xDist / yDist);
   1126                 aspectRatio = xDist / yDist;
   1127             }
   1128             break;
   1129         }
   1130         }
   1131     }
   1132 
   1133     RefPtr<Gradient> gradient = Gradient::create(firstPoint, firstRadius, secondPoint, secondRadius, aspectRatio);
   1134 
   1135     gradient->setDrawsInPMColorSpace(true);
   1136 
   1137     // addStops() only uses maxExtent for repeating gradients.
   1138     float maxExtent = 0;
   1139     if (m_repeating) {
   1140         FloatPoint corner;
   1141         maxExtent = distanceToFarthestCorner(secondPoint, size, corner);
   1142     }
   1143 
   1144     // Now add the stops.
   1145     addStops(gradient.get(), conversionData, maxExtent);
   1146 
   1147     return gradient.release();
   1148 }
   1149 
   1150 bool CSSRadialGradientValue::equals(const CSSRadialGradientValue& other) const
   1151 {
   1152     if (m_gradientType == CSSDeprecatedRadialGradient)
   1153         return other.m_gradientType == m_gradientType
   1154             && compareCSSValuePtr(m_firstX, other.m_firstX)
   1155             && compareCSSValuePtr(m_firstY, other.m_firstY)
   1156             && compareCSSValuePtr(m_secondX, other.m_secondX)
   1157             && compareCSSValuePtr(m_secondY, other.m_secondY)
   1158             && compareCSSValuePtr(m_firstRadius, other.m_firstRadius)
   1159             && compareCSSValuePtr(m_secondRadius, other.m_secondRadius)
   1160             && m_stops == other.m_stops;
   1161 
   1162     if (m_repeating != other.m_repeating)
   1163         return false;
   1164 
   1165     bool equalXandY = false;
   1166     if (m_firstX && m_firstY)
   1167         equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && compareCSSValuePtr(m_firstY, other.m_firstY);
   1168     else if (m_firstX)
   1169         equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && !other.m_firstY;
   1170     else if (m_firstY)
   1171         equalXandY = compareCSSValuePtr(m_firstY, other.m_firstY) && !other.m_firstX;
   1172     else
   1173         equalXandY = !other.m_firstX && !other.m_firstY;
   1174 
   1175     if (!equalXandY)
   1176         return false;
   1177 
   1178     bool equalShape = true;
   1179     bool equalSizingBehavior = true;
   1180     bool equalHorizontalAndVerticalSize = true;
   1181 
   1182     if (m_shape)
   1183         equalShape = compareCSSValuePtr(m_shape, other.m_shape);
   1184     else if (m_sizingBehavior)
   1185         equalSizingBehavior = compareCSSValuePtr(m_sizingBehavior, other.m_sizingBehavior);
   1186     else if (m_endHorizontalSize && m_endVerticalSize)
   1187         equalHorizontalAndVerticalSize = compareCSSValuePtr(m_endHorizontalSize, other.m_endHorizontalSize) && compareCSSValuePtr(m_endVerticalSize, other.m_endVerticalSize);
   1188     else {
   1189         equalShape = !other.m_shape;
   1190         equalSizingBehavior = !other.m_sizingBehavior;
   1191         equalHorizontalAndVerticalSize = !other.m_endHorizontalSize && !other.m_endVerticalSize;
   1192     }
   1193     return equalShape && equalSizingBehavior && equalHorizontalAndVerticalSize && m_stops == other.m_stops;
   1194 }
   1195 
   1196 void CSSRadialGradientValue::traceAfterDispatch(Visitor* visitor)
   1197 {
   1198     visitor->trace(m_firstRadius);
   1199     visitor->trace(m_secondRadius);
   1200     visitor->trace(m_shape);
   1201     visitor->trace(m_sizingBehavior);
   1202     visitor->trace(m_endHorizontalSize);
   1203     visitor->trace(m_endVerticalSize);
   1204     CSSGradientValue::traceAfterDispatch(visitor);
   1205 }
   1206 
   1207 } // namespace blink
   1208