Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

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 10 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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 "core/css/CSSGradientValue.h"
 
 #include "core/CSSValueKeywords.h"
 #include "core/css/CSSCalculationValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "core/css/CSSValuePair.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/TextLinkColors.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/GradientGeneratedImage.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #include <utility>
 
 namespace blink {
 
+namespace {
+
+static bool colorIsDerivedFromElement(const CSSIdentifierValue& value) {
+  CSSValueID valueID = value.getValueID();
+  switch (valueID) {
+    case CSSValueInternalQuirkInherit:
+    case CSSValueWebkitLink:
+    case CSSValueWebkitActivelink:
+    case CSSValueCurrentcolor:
+      return true;
+    default:
+      return false;
+  }
+}
+}
+
 DEFINE_TRACE(CSSGradientColorStop) {
   visitor->trace(m_position);
   visitor->trace(m_color);
 }
 
 PassRefPtr<Image> CSSGradientValue::image(const LayoutObject& layoutObject,
                                           const IntSize& size) {
   if (size.isEmpty())
     return nullptr;
 
@@ skipping 446 matching lines @@
                                const IntSize& size,
                                bool isHorizontal) {
   int origin = 0;
   int sign = 1;
   int edgeDistance = isHorizontal ? size.width() : size.height();
 
   // In this case the center of the gradient is given relative to an edge in the form of:
   // [ top | bottom | right | left ] [ <percentage> | <length> ].
   if (value->isValuePair()) {
     const CSSValuePair& pair = toCSSValuePair(*value);
-    CSSValueID originID = toCSSPrimitiveValue(pair.first()).getValueID();
+    CSSValueID originID = toCSSIdentifierValue(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->isIdentifierValue()) {
+    switch (toCSSIdentifierValue(value)->getValueID()) {
+      case CSSValueTop:
+        DCHECK(!isHorizontal);
+        return 0;
+      case CSSValueLeft:
+        DCHECK(isHorizontal);
+        return 0;
+      case CSSValueBottom:
+        DCHECK(!isHorizontal);
+        return size.height();
+      case CSSValueRight:
+        DCHECK(isHorizontal);
+        return size.width();
+      case CSSValueCenter:
+        return origin + sign * .5f * edgeDistance;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
   const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
   if (primitiveValue->isNumber())
     return origin +
            sign * primitiveValue->getFloatValue() * conversionData.zoom();
 
   if (primitiveValue->isPercentage())
     return origin +
            sign * primitiveValue->getFloatValue() / 100.f * edgeDistance;
 
   if (primitiveValue->isCalculatedPercentageWithLength())
     return origin +
            sign *
                primitiveValue->cssCalcValue()
                    ->toCalcValue(conversionData)
                    ->evaluate(edgeDistance);
 
-  switch (primitiveValue->getValueID()) {
-    case CSSValueTop:
-      ASSERT(!isHorizontal);
-      return 0;
-    case CSSValueLeft:
-      ASSERT(isHorizontal);
-      return 0;
-    case CSSValueBottom:
-      ASSERT(!isHorizontal);
-      return size.height();
-    case CSSValueRight:
-      ASSERT(isHorizontal);
-      return size.width();
-    case CSSValueCenter:
-      return origin + sign * .5f * edgeDistance;
-    default:
-      break;
-  }
-
   return origin + sign * primitiveValue->computeLength<float>(conversionData);
 }
 
 FloatPoint CSSGradientValue::computeEndPoint(
     CSSValue* horizontal,
     CSSValue* vertical,
     const CSSToLengthConversionData& conversionData,
     const IntSize& size) {
   FloatPoint result;
 
   if (horizontal)
     result.setX(positionFromValue(horizontal, conversionData, size, true));
 
   if (vertical)
     result.setY(positionFromValue(vertical, conversionData, size, false));
 
   return result;
 }
 
 bool CSSGradientValue::isCacheable() const {
   for (size_t i = 0; i < m_stops.size(); ++i) {
     const CSSGradientColorStop& stop = m_stops[i];
 
-    if (!stop.isHint() && stop.m_color->isPrimitiveValue() &&
-        toCSSPrimitiveValue(*stop.m_color).colorIsDerivedFromElement())
+    if (!stop.isHint() && stop.m_color->isIdentifierValue() &&
+        colorIsDerivedFromElement(toCSSIdentifierValue(*stop.m_color)))
       return false;
 
     if (!stop.m_position)
       continue;
 
     if (stop.m_position->isFontRelativeLength())
       return false;
   }
 
   return true;
@@ skipping 72 matching lines @@
       result.append("repeating-linear-gradient(");
     else
       result.append("linear-gradient(");
 
     bool wroteSomething = false;
 
     if (m_angle && m_angle->computeDegrees() != 180) {
       result.append(m_angle->cssText());
       wroteSomething = true;
     } else if ((m_firstX || m_firstY) &&
-               !(!m_firstX && m_firstY && m_firstY->isPrimitiveValue() &&
-                 toCSSPrimitiveValue(m_firstY.get())->getValueID() ==
+               !(!m_firstX && m_firstY && m_firstY->isIdentifierValue() &&
+                 toCSSIdentifierValue(m_firstY.get())->getValueID() ==
                      CSSValueBottom)) {
       result.append("to ");
       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());
@@ skipping 123 matching lines @@
         if (m_firstX)
           secondPoint.setX(size.width() - firstPoint.x());
         if (m_firstY)
           secondPoint.setY(size.height() - firstPoint.y());
         break;
       case CSSLinearGradient:
         if (m_firstX && m_firstY) {
           // "Magic" corners, so the 50% line touches two corners.
           float rise = size.width();
           float run = size.height();
-          if (m_firstX && m_firstX->isPrimitiveValue() &&
-              toCSSPrimitiveValue(m_firstX.get())->getValueID() == CSSValueLeft)
+          if (m_firstX && m_firstX->isIdentifierValue() &&
+              toCSSIdentifierValue(m_firstX.get())->getValueID() ==
+                  CSSValueLeft)
             run *= -1;
-          if (m_firstY && m_firstY->isPrimitiveValue() &&
-              toCSSPrimitiveValue(m_firstY.get())->getValueID() ==
+          if (m_firstY && m_firstY->isIdentifierValue() &&
+              toCSSIdentifierValue(m_firstY.get())->getValueID() ==
                   CSSValueBottom)
             rise *= -1;
           // Compute angle, and flip it back to "bearing angle" degrees.
           float angle = 90 - rad2deg(atan2(rise, run));
           endPointsFromAngle(angle, size, firstPoint, secondPoint,
                              m_gradientType);
         } else if (m_firstX || m_firstY) {
           secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(),
                                         conversionData, size);
           if (m_firstX)
@@ skipping 444 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 blink