CSSValue Immediates: Make CSSPrimitiveValue a container

Source/core/css/BasicShapeFunctions.cpp

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. 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.
@@ skipping 22 matching lines @@
 #include "core/css/CSSBasicShapes.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/Pair.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/BasicShapes.h"
 #include "core/style/ComputedStyle.h"
 
 namespace blink {
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForCenterCoordinate(CSSValuePool& pool, const ComputedStyle& style, const BasicShapeCenterCoordinate& center, EBoxOrient orientation)
+static CSSPrimitiveValue valueForCenterCoordinate(CSSValuePool& pool, const ComputedStyle& style, const BasicShapeCenterCoordinate& center, EBoxOrient orientation)
 {
     if (center.direction() == BasicShapeCenterCoordinate::TopLeft)
         return pool.createValue(center.length(), style);
 
     CSSValueID keyword = orientation == HORIZONTAL ? CSSValueRight : CSSValueBottom;
 
     return pool.createValue(Pair::create(pool.createIdentifierValue(keyword), pool.createValue(center.length(), style), Pair::DropIdenticalValues));
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> basicShapeRadiusToCSSValue(CSSValuePool& pool, const ComputedStyle& style, const BasicShapeRadius& radius)
+static CSSPrimitiveValue basicShapeRadiusToCSSValue(CSSValuePool& pool, const ComputedStyle& style, const BasicShapeRadius& radius)
 {
     switch (radius.type()) {
     case BasicShapeRadius::Value:
         return pool.createValue(radius.value(), style);
     case BasicShapeRadius::ClosestSide:
         return pool.createIdentifierValue(CSSValueClosestSide);
     case BasicShapeRadius::FarthestSide:
         return pool.createIdentifierValue(CSSValueFarthestSide);
     }
 
     ASSERT_NOT_REACHED();
-    return nullptr;
+    return pool.createValue(radius.value(), style);
 }
 
 CSSValue valueForBasicShape(const ComputedStyle& style, const BasicShape* basicShape)
 {
     CSSValuePool& pool = cssValuePool();
 
     RefPtrWillBeRawPtr<CSSBasicShape> basicShapeValue = nullptr;
     switch (basicShape->type()) {
     case BasicShape::BasicShapeCircleType: {
         const BasicShapeCircle* circle = toBasicShapeCircle(basicShape);
@@ skipping 46 matching lines @@
         break;
     }
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 
     return pool.createValue(basicShapeValue.release());
 }
 
-static Length convertToLength(const StyleResolverState& state, CSSPrimitiveValue* value)
+static Length convertToLength(const StyleResolverState& state, NullableCSSValue value)
 {
     if (!value)
         return Length(0, Fixed);
-    return value->convertToLength(state.cssToLengthConversionData());
+    return toCSSPrimitiveValue(*value).convertToLength(state.cssToLengthConversionData());
 }
 
-static LengthSize convertToLengthSize(const StyleResolverState& state, CSSPrimitiveValue* value)
+static LengthSize convertToLengthSize(const StyleResolverState& state, NullableCSSValue value)
 {
     if (!value)
         return LengthSize(Length(0, Fixed), Length(0, Fixed));
 
-    Pair* pair = value->getPairValue();
+    Pair* pair = toCSSPrimitiveValue(*value).getPairValue();
     return LengthSize(convertToLength(state, pair->first()), convertToLength(state, pair->second()));
 }
 
-static BasicShapeCenterCoordinate convertToCenterCoordinate(const StyleResolverState& state, CSSPrimitiveValue* value)
+static BasicShapeCenterCoordinate convertToCenterCoordinate(const StyleResolverState& state, NullableCSSValue value)
 {
     BasicShapeCenterCoordinate::Direction direction;
     Length offset = Length(0, Fixed);
 
     CSSValueID keyword = CSSValueTop;
     if (!value) {
         keyword = CSSValueCenter;
-    } else if (value->isValueID()) {
-        keyword = value->getValueID();
-    } else if (Pair* pair = value->getPairValue()) {
-        keyword = pair->first()->getValueID();
+    } else if (toCSSPrimitiveValue(*value).isValueID()) {
+        keyword = toCSSPrimitiveValue(*value).getValueID();
+    } else if (Pair* pair = toCSSPrimitiveValue(*value).getPairValue()) {
+        keyword = toCSSPrimitiveValue(*pair->first()).getValueID();
         offset = convertToLength(state, pair->second());
     } else {
         offset = convertToLength(state, value);
     }
 
     switch (keyword) {
     case CSSValueTop:
     case CSSValueLeft:
         direction = BasicShapeCenterCoordinate::TopLeft;
         break;
     case CSSValueRight:
     case CSSValueBottom:
         direction = BasicShapeCenterCoordinate::BottomRight;
         break;
     case CSSValueCenter:
         direction = BasicShapeCenterCoordinate::TopLeft;
         offset = Length(50, Percent);
         break;
     default:
         ASSERT_NOT_REACHED();
         direction = BasicShapeCenterCoordinate::TopLeft;
         break;
     }
 
     return BasicShapeCenterCoordinate(direction, offset);
 }
 
-static BasicShapeRadius cssValueToBasicShapeRadius(const StyleResolverState& state, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius)
+static BasicShapeRadius cssValueToBasicShapeRadius(const StyleResolverState& state, NullableCSSValue radius)
 {
     if (!radius)
         return BasicShapeRadius(BasicShapeRadius::ClosestSide);
 
-    if (radius->isValueID()) {
-        switch (radius->getValueID()) {
+    if (toCSSPrimitiveValue(*radius).isValueID()) {
+        switch (toCSSPrimitiveValue(*radius).getValueID()) {
         case CSSValueClosestSide:
             return BasicShapeRadius(BasicShapeRadius::ClosestSide);
         case CSSValueFarthestSide:
             return BasicShapeRadius(BasicShapeRadius::FarthestSide);
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
-    return BasicShapeRadius(convertToLength(state, radius.get()));
+    return BasicShapeRadius(convertToLength(state, radius));
 }
 
 PassRefPtr<BasicShape> basicShapeForValue(const StyleResolverState& state, const CSSBasicShape* basicShapeValue)
 {
     RefPtr<BasicShape> basicShape;
 
     switch (basicShapeValue->type()) {
     case CSSBasicShape::CSSBasicShapeCircleType: {
         const CSSBasicShapeCircle* circleValue = toCSSBasicShapeCircle(basicShapeValue);
         RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
@@ skipping 15 matching lines @@
         ellipse->setRadiusY(cssValueToBasicShapeRadius(state, ellipseValue->radiusY()));
 
         basicShape = ellipse.release();
         break;
     }
     case CSSBasicShape::CSSBasicShapePolygonType: {
         const CSSBasicShapePolygon* polygonValue = toCSSBasicShapePolygon(basicShapeValue);
         RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
 
         polygon->setWindRule(polygonValue->windRule());
-        const WillBeHeapVector<RefPtrWillBeMember<CSSPrimitiveValue>>& values = polygonValue->values();
+        const WillBeHeapVector<CSSValue>& values = polygonValue->values();
         for (unsigned i = 0; i < values.size(); i += 2)
             polygon->appendPoint(convertToLength(state, values.at(i).get()), convertToLength(state, values.at(i + 1).get()));
 
         basicShape = polygon.release();
         break;
     }
     case CSSBasicShape::CSSBasicShapeInsetType: {
         const CSSBasicShapeInset* rectValue = toCSSBasicShapeInset(basicShapeValue);
         RefPtr<BasicShapeInset> rect = BasicShapeInset::create();
 
@@ skipping 18 matching lines @@
 }
 
 FloatPoint floatPointForCenterCoordinate(const BasicShapeCenterCoordinate& centerX, const BasicShapeCenterCoordinate& centerY, FloatSize boxSize)
 {
     float x = floatValueForLength(centerX.computedLength(), boxSize.width());
     float y = floatValueForLength(centerY.computedLength(), boxSize.height());
     return FloatPoint(x, y);
 }
 
 }