CSSValue Immediates: Make CSSPrimitiveValue a container

Source/core/css/CSSCalculationValue.cpp

 /*
  * Copyright (C) 2011, 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 169 matching lines @@
 {
     return clampToPermittedRange(m_expression->computeLengthPx(conversionData));
 }
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSCalcExpressionNode)
 
 class CSSCalcPrimitiveValue final : public CSSCalcExpressionNode {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(CSSCalcPrimitiveValue);
 public:
 
-    static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
+    static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(CSSPrimitiveValue value, bool isInteger)
     {
         return adoptRefWillBeNoop(new CSSCalcPrimitiveValue(value, isInteger));
     }
 
     static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(double value, CSSPrimitiveValue::UnitType type, bool isInteger)
     {
         if (std::isnan(value) || std::isinf(value))
             return nullptr;
-        return adoptRefWillBeNoop(new CSSCalcPrimitiveValue(CSSPrimitiveValue::create(value, type).get(), isInteger));
+        return adoptRefWillBeNoop(new CSSCalcPrimitiveValue(CSSPrimitiveValue::create(value, type), isInteger));
     }
 
     virtual bool isZero() const override
     {
-        return !m_value->getDoubleValue();
+        return !toCSSPrimitiveValue(m_value).getDoubleValue();
     }
 
     virtual String customCSSText() const override
     {
-        return m_value->cssText();
+        return m_value.cssText();
     }
 
     virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const override
     {
         switch (m_category) {
         case CalcLength:
-            value.pixels += m_value->computeLength<float>(conversionData) * multiplier;
+            value.pixels += toCSSPrimitiveValue(m_value).computeLength<float>(conversionData) * multiplier;
             break;
         case CalcPercent:
-            ASSERT(m_value->isPercentage());
-            value.percent += m_value->getDoubleValue() * multiplier;
+            ASSERT(toCSSPrimitiveValue(m_value).isPercentage());
+            value.percent += toCSSPrimitiveValue(m_value).getDoubleValue() * multiplier;
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 
     virtual double doubleValue() const override
     {
         if (hasDoubleValue(primitiveType()))
-            return m_value->getDoubleValue();
+            return toCSSPrimitiveValue(m_value).getDoubleValue();
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const override
     {
         switch (m_category) {
         case CalcLength:
-            return m_value->computeLength<double>(conversionData);
+            return toCSSPrimitiveValue(m_value).computeLength<double>(conversionData);
         case CalcNumber:
         case CalcPercent:
-            return m_value->getDoubleValue();
+            return toCSSPrimitiveValue(m_value).getDoubleValue();
         case CalcAngle:
         case CalcFrequency:
         case CalcPercentLength:
         case CalcPercentNumber:
         case CalcTime:
         case CalcOther:
             ASSERT_NOT_REACHED();
             break;
         }
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     virtual void accumulateLengthArray(CSSLengthArray& lengthArray, CSSLengthTypeArray& lengthTypeArray, double multiplier) const override
     {
         ASSERT(category() != CalcNumber);
-        m_value->accumulateLengthArray(lengthArray, lengthTypeArray, multiplier);
+        toCSSPrimitiveValue(m_value).accumulateLengthArray(lengthArray, lengthTypeArray, multiplier);
     }
 
     virtual bool equals(const CSSCalcExpressionNode& other) const override
     {
         if (type() != other.type())
             return false;
 
-        return compareCSSValuePtr(m_value, static_cast<const CSSCalcPrimitiveValue&>(other).m_value);
+        return m_value.equals(static_cast<const CSSCalcPrimitiveValue&>(other).m_value);
     }
 
     virtual Type type() const override { return CssCalcPrimitiveValue; }
     virtual CSSPrimitiveValue::UnitType primitiveType() const override
     {
-        return m_value->primitiveType();
+        return toCSSPrimitiveValue(m_value).primitiveType();
     }
 
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_value);
         CSSCalcExpressionNode::trace(visitor);
     }
 
 private:
-    CSSCalcPrimitiveValue(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
-        : CSSCalcExpressionNode(unitCategory(value->primitiveType()), isInteger)
+    CSSCalcPrimitiveValue(CSSPrimitiveValue value, bool isInteger)
+        : CSSCalcExpressionNode(unitCategory(value.primitiveType()), isInteger)
         , m_value(value)
     {
     }
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_value;
+    CSSValue m_value;
 };
 
 static const CalculationCategory addSubtractResult[CalcOther][CalcOther] = {
 //                        CalcNumber         CalcLength         CalcPercent        CalcPercentNumber  CalcPercentLength  CalcAngle  CalcTime   CalcFrequency
 /* CalcNumber */        { CalcNumber,        CalcOther,         CalcPercentNumber, CalcPercentNumber, CalcOther,         CalcOther, CalcOther, CalcOther     },
 /* CalcLength */        { CalcOther,         CalcLength,        CalcPercentLength, CalcOther,         CalcPercentLength, CalcOther, CalcOther, CalcOther     },
 /* CalcPercent */       { CalcPercentNumber, CalcPercentLength, CalcPercent,       CalcPercentNumber, CalcPercentLength, CalcOther, CalcOther, CalcOther     },
 /* CalcPercentNumber */ { CalcPercentNumber, CalcOther,         CalcPercentNumber, CalcPercentNumber, CalcOther,         CalcOther, CalcOther, CalcOther     },
 /* CalcPercentLength */ { CalcOther,         CalcPercentLength, CalcPercentLength, CalcOther,         CalcPercentLength, CalcOther, CalcOther, CalcOther     },
 /* CalcAngle  */        { CalcOther,         CalcOther,         CalcOther,         CalcOther,         CalcOther,         CalcAngle, CalcOther, CalcOther     },
@@ skipping 422 matching lines @@
         ASSERT_WITH_SECURITY_IMPLICATION(*index <= tokens->size());
         return true;
     }
 
     bool parseValueExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
     {
         return parseAdditiveValueExpression(tokens, depth, index, result);
     }
 };
 
-PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
+PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(CSSPrimitiveValue value, bool isInteger)
 {
     return CSSCalcPrimitiveValue::create(value, isInteger);
 }
 
 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
 {
     return CSSCalcBinaryOperation::create(leftSide, rightSide, op);
 }
 
 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(double pixels, double percent)
@@ skipping 17 matching lines @@
     return adoptRefWillBeNoop(new CSSCalcValue(expression, range));
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSCalcValue)
 {
     visitor->trace(m_expression);
     CSSValueObject::traceAfterDispatch(visitor);
 }
 
 } // namespace blink