Remove RawPtr from core/css

third_party/WebKit/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 155 matching lines @@
 }
 
 double CSSCalcValue::computeLengthPx(const CSSToLengthConversionData& conversionData) const
 {
     return clampToPermittedRange(m_expression->computeLengthPx(conversionData));
 }
 
 class CSSCalcPrimitiveValue final : public CSSCalcExpressionNode {
 public:
 
-    static RawPtr<CSSCalcPrimitiveValue> create(RawPtr<CSSPrimitiveValue> value, bool isInteger)
+    static CSSCalcPrimitiveValue* create(CSSPrimitiveValue* value, bool isInteger)
     {
         return new CSSCalcPrimitiveValue(value, isInteger);
     }
 
-    static RawPtr<CSSCalcPrimitiveValue> create(double value, CSSPrimitiveValue::UnitType type, bool isInteger)
+    static CSSCalcPrimitiveValue* create(double value, CSSPrimitiveValue::UnitType type, bool isInteger)
     {
         if (std::isnan(value) || std::isinf(value))
             return nullptr;
-        return new CSSCalcPrimitiveValue(CSSPrimitiveValue::create(value, type).get(), isInteger);
+        return new CSSCalcPrimitiveValue(CSSPrimitiveValue::create(value, type), isInteger);
     }
 
     bool isZero() const override
     {
         return !m_value->getDoubleValue();
     }
 
     String customCSSText() const override
     {
         return m_value->cssText();
@@ skipping 64 matching lines @@
     }
 
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_value);
         CSSCalcExpressionNode::trace(visitor);
     }
 
 private:
-    CSSCalcPrimitiveValue(RawPtr<CSSPrimitiveValue> value, bool isInteger)
+    CSSCalcPrimitiveValue(CSSPrimitiveValue* value, bool isInteger)
         : CSSCalcExpressionNode(unitCategory(value->typeWithCalcResolved()), isInteger)
         , m_value(value)
     {
     }
 
     Member<CSSPrimitiveValue> m_value;
 };
 
 static const CalculationCategory addSubtractResult[CalcOther][CalcOther] = {
 //                        CalcNumber         CalcLength         CalcPercent        CalcPercentNumber  CalcPercentLength  CalcAngle  CalcTime   CalcFrequency
@@ skipping 36 matching lines @@
 static bool isIntegerResult(const CSSCalcExpressionNode* leftSide, const CSSCalcExpressionNode* rightSide, CalcOperator op)
 {
     // Not testing for actual integer values.
     // Performs W3C spec's type checking for calc integers.
     // http://www.w3.org/TR/css3-values/#calc-type-checking
     return op != CalcDivide && leftSide->isInteger() && rightSide->isInteger();
 }
 
 class CSSCalcBinaryOperation final : public CSSCalcExpressionNode {
 public:
-    static RawPtr<CSSCalcExpressionNode> create(RawPtr<CSSCalcExpressionNode> leftSide, RawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
+    static CSSCalcExpressionNode* create(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide, CalcOperator op)
     {
         ASSERT(leftSide->category() != CalcOther && rightSide->category() != CalcOther);
 
         CalculationCategory newCategory = determineCategory(*leftSide, *rightSide, op);
         if (newCategory == CalcOther)
             return nullptr;
 
         return new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory);
     }
 
-    static RawPtr<CSSCalcExpressionNode> createSimplified(RawPtr<CSSCalcExpressionNode> leftSide, RawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
+    static CSSCalcExpressionNode* createSimplified(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide, CalcOperator op)
     {
         CalculationCategory leftCategory = leftSide->category();
         CalculationCategory rightCategory = rightSide->category();
         ASSERT(leftCategory != CalcOther && rightCategory != CalcOther);
 
-        bool isInteger = isIntegerResult(leftSide.get(), rightSide.get(), op);
+        bool isInteger = isIntegerResult(leftSide, rightSide, op);
 
         // Simplify numbers.
         if (leftCategory == CalcNumber && rightCategory == CalcNumber) {
             return CSSCalcPrimitiveValue::create(evaluateOperator(leftSide->doubleValue(), rightSide->doubleValue(), op), CSSPrimitiveValue::UnitType::Number, isInteger);
         }
 
         // Simplify addition and subtraction between same types.
         if (op == CalcAdd || op == CalcSubtract) {
             if (leftCategory == rightSide->category()) {
                 CSSPrimitiveValue::UnitType leftType = leftSide->typeWithCalcResolved();
                 if (hasDoubleValue(leftType)) {
                     CSSPrimitiveValue::UnitType rightType = rightSide->typeWithCalcResolved();
                     if (leftType == rightType)
                         return CSSCalcPrimitiveValue::create(evaluateOperator(leftSide->doubleValue(), rightSide->doubleValue(), op), leftType, isInteger);
                     CSSPrimitiveValue::UnitCategory leftUnitCategory = CSSPrimitiveValue::unitTypeToUnitCategory(leftType);
                     if (leftUnitCategory != CSSPrimitiveValue::UOther && leftUnitCategory == CSSPrimitiveValue::unitTypeToUnitCategory(rightType)) {
                         CSSPrimitiveValue::UnitType canonicalType = CSSPrimitiveValue::canonicalUnitTypeForCategory(leftUnitCategory);
                         if (canonicalType != CSSPrimitiveValue::UnitType::Unknown) {
                             double leftValue = leftSide->doubleValue() * CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(leftType);
                             double rightValue = rightSide->doubleValue() * CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(rightType);
                             return CSSCalcPrimitiveValue::create(evaluateOperator(leftValue, rightValue, op), canonicalType, isInteger);
                         }
                     }
                 }
             }
         } else {
             // Simplify multiplying or dividing by a number for simplifiable types.
             ASSERT(op == CalcMultiply || op == CalcDivide);
-            CSSCalcExpressionNode* numberSide = getNumberSide(leftSide.get(), rightSide.get());
+            CSSCalcExpressionNode* numberSide = getNumberSide(leftSide, rightSide);
             if (!numberSide)
                 return create(leftSide, rightSide, op);
             if (numberSide == leftSide && op == CalcDivide)
                 return nullptr;
-            CSSCalcExpressionNode* otherSide = leftSide == numberSide ? rightSide.get() : leftSide.get();
+            CSSCalcExpressionNode* otherSide = leftSide == numberSide ? rightSide : leftSide;
 
             double number = numberSide->doubleValue();
             if (std::isnan(number) || std::isinf(number))
                 return nullptr;
             if (op == CalcDivide && !number)
                 return nullptr;
 
             CSSPrimitiveValue::UnitType otherType = otherSide->typeWithCalcResolved();
             if (hasDoubleValue(otherType))
                 return CSSCalcPrimitiveValue::create(evaluateOperator(otherSide->doubleValue(), number, op), otherType, isInteger);
@@ skipping 138 matching lines @@
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_leftSide);
         visitor->trace(m_rightSide);
         CSSCalcExpressionNode::trace(visitor);
     }
 
 private:
-    CSSCalcBinaryOperation(RawPtr<CSSCalcExpressionNode> leftSide, RawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op, CalculationCategory category)
-        : CSSCalcExpressionNode(category, isIntegerResult(leftSide.get(), rightSide.get(), op))
+    CSSCalcBinaryOperation(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide, CalcOperator op, CalculationCategory category)
+        : CSSCalcExpressionNode(category, isIntegerResult(leftSide, rightSide, op))
         , m_leftSide(leftSide)
         , m_rightSide(rightSide)
         , m_operator(op)
     {
     }
 
     static CSSCalcExpressionNode* getNumberSide(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide)
     {
         if (leftSide->category() == CalcNumber)
             return leftSide;
@@ skipping 35 matching lines @@
     if (tokens.atEnd())
         return NoMoreTokens;
     if (*depth > maxExpressionDepth)
         return TooDeep;
     return OK;
 }
 
 class CSSCalcExpressionNodeParser {
     STACK_ALLOCATED();
 public:
-    RawPtr<CSSCalcExpressionNode> parseCalc(CSSParserTokenRange tokens)
+    CSSCalcExpressionNode* parseCalc(CSSParserTokenRange tokens)
     {
         Value result;
         tokens.consumeWhitespace();
         bool ok = parseValueExpression(tokens, 0, &result);
         if (!ok || !tokens.atEnd())
             return nullptr;
         return result.value;
     }
 
 private:
@@ skipping 97 matching lines @@
 
         return true;
     }
 
     bool parseValueExpression(CSSParserTokenRange& tokens, int depth, Value* result)
     {
         return parseAdditiveValueExpression(tokens, depth, result);
     }
 };
 
-RawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(RawPtr<CSSPrimitiveValue> value, bool isInteger)
+CSSCalcExpressionNode* CSSCalcValue::createExpressionNode(CSSPrimitiveValue* value, bool isInteger)
 {
     return CSSCalcPrimitiveValue::create(value, isInteger);
 }
 
-RawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(RawPtr<CSSCalcExpressionNode> leftSide, RawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
+CSSCalcExpressionNode* CSSCalcValue::createExpressionNode(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide, CalcOperator op)
 {
     return CSSCalcBinaryOperation::create(leftSide, rightSide, op);
 }
 
-RawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(double pixels, double percent)
+CSSCalcExpressionNode* CSSCalcValue::createExpressionNode(double pixels, double percent)
 {
     return createExpressionNode(
         createExpressionNode(CSSPrimitiveValue::create(pixels, CSSPrimitiveValue::UnitType::Pixels), pixels == trunc(pixels)),
         createExpressionNode(CSSPrimitiveValue::create(percent, CSSPrimitiveValue::UnitType::Percentage), percent == trunc(percent)),
         CalcAdd);
 }
 
-RawPtr<CSSCalcValue> CSSCalcValue::create(const CSSParserTokenRange& tokens, ValueRange range)
+CSSCalcValue* CSSCalcValue::create(const CSSParserTokenRange& tokens, ValueRange range)
 {
     CSSCalcExpressionNodeParser parser;
-    RawPtr<CSSCalcExpressionNode> expression = parser.parseCalc(tokens);
+    CSSCalcExpressionNode* expression = parser.parseCalc(tokens);
 
     return expression ? new CSSCalcValue(expression, range) : nullptr;
 }
 
-RawPtr<CSSCalcValue> CSSCalcValue::create(RawPtr<CSSCalcExpressionNode> expression, ValueRange range)
+CSSCalcValue* CSSCalcValue::create(CSSCalcExpressionNode* expression, ValueRange range)
 {
     return new CSSCalcValue(expression, range);
 }
 
 } // namespace blink