Replace FINAL and OVERRIDE with their C++11 counterparts in Source/core/[css|rendering|clipboard]

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 165 matching lines @@
     return clampToPermittedRange(m_expression->doubleValue());
 }
 
 double CSSCalcValue::computeLengthPx(const CSSToLengthConversionData& conversionData) const
 {
     return clampToPermittedRange(m_expression->computeLengthPx(conversionData));
 }
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSCalcExpressionNode)
 
-class CSSCalcPrimitiveValue FINAL : public CSSCalcExpressionNode {
+class CSSCalcPrimitiveValue final : public CSSCalcExpressionNode {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
 
     static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(PassRefPtrWillBeRawPtr<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));
     }
 
-    virtual bool isZero() const OVERRIDE
+    virtual bool isZero() const override
     {
         return !m_value->getDoubleValue();
     }
 
-    virtual String customCSSText() const OVERRIDE
+    virtual String customCSSText() const override
     {
         return m_value->cssText();
     }
 
-    virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const OVERRIDE
+    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;
             break;
         case CalcPercent:
             ASSERT(m_value->isPercentage());
             value.percent += m_value->getDoubleValue() * multiplier;
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 
-    virtual double doubleValue() const OVERRIDE
+    virtual double doubleValue() const override
     {
         if (hasDoubleValue(primitiveType()))
             return m_value->getDoubleValue();
         ASSERT_NOT_REACHED();
         return 0;
     }
 
-    virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const OVERRIDE
+    virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const override
     {
         switch (m_category) {
         case CalcLength:
             return m_value->computeLength<double>(conversionData);
         case CalcNumber:
         case CalcPercent:
             return 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, double multiplier) const
     {
         ASSERT(category() != CalcNumber);
         m_value->accumulateLengthArray(lengthArray, multiplier);
     }
 
-    virtual bool equals(const CSSCalcExpressionNode& other) const OVERRIDE
+    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);
     }
 
-    virtual Type type() const OVERRIDE { return CssCalcPrimitiveValue; }
-    virtual CSSPrimitiveValue::UnitType primitiveType() const OVERRIDE
+    virtual Type type() const override { return CssCalcPrimitiveValue; }
+    virtual CSSPrimitiveValue::UnitType primitiveType() const override
     {
         return m_value->primitiveType();
     }
 
 
     virtual void trace(Visitor* visitor)
     {
         visitor->trace(m_value);
         CSSCalcExpressionNode::trace(visitor);
     }
@@ skipping 47 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 {
+class CSSCalcBinaryOperation final : public CSSCalcExpressionNode {
 public:
     static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> create(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
     {
         ASSERT(leftSide->category() != CalcOther && rightSide->category() != CalcOther);
 
         CalculationCategory newCategory = determineCategory(*leftSide, *rightSide, op);
         if (newCategory == CalcOther)
             return nullptr;
 
         return adoptRefWillBeNoop(new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory));
@@ skipping 48 matching lines @@
                 return nullptr;
 
             CSSPrimitiveValue::UnitType otherType = otherSide->primitiveType();
             if (hasDoubleValue(otherType))
                 return CSSCalcPrimitiveValue::create(evaluateOperator(otherSide->doubleValue(), number, op), otherType, isInteger);
         }
 
         return create(leftSide, rightSide, op);
     }
 
-    virtual bool isZero() const OVERRIDE
+    virtual bool isZero() const override
     {
         return !doubleValue();
     }
 
-    virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const OVERRIDE
+    virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const override
     {
         switch (m_operator) {
         case CalcAdd:
             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
             m_rightSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
             break;
         case CalcSubtract:
             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
             m_rightSide->accumulatePixelsAndPercent(conversionData, value, -multiplier);
             break;
         case CalcMultiply:
             ASSERT((m_leftSide->category() == CalcNumber) != (m_rightSide->category() == CalcNumber));
             if (m_leftSide->category() == CalcNumber)
                 m_rightSide->accumulatePixelsAndPercent(conversionData, value, multiplier * m_leftSide->doubleValue());
             else
                 m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier * m_rightSide->doubleValue());
             break;
         case CalcDivide:
             ASSERT(m_rightSide->category() == CalcNumber);
             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier / m_rightSide->doubleValue());
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 
-    virtual double doubleValue() const OVERRIDE
+    virtual double doubleValue() const override
     {
         return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
     }
 
-    virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const OVERRIDE
+    virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const override
     {
         const double leftValue = m_leftSide->computeLengthPx(conversionData);
         const double rightValue = m_rightSide->computeLengthPx(conversionData);
         return evaluate(leftValue, rightValue);
     }
 
     virtual void accumulateLengthArray(CSSLengthArray& lengthArray, double multiplier) const
     {
         switch (m_operator) {
         case CalcAdd:
@@ skipping 27 matching lines @@
         result.append(leftExpression);
         result.append(' ');
         result.append(static_cast<char>(op));
         result.append(' ');
         result.append(rightExpression);
         result.append(')');
 
         return result.toString();
     }
 
-    virtual String customCSSText() const OVERRIDE
+    virtual String customCSSText() const override
     {
         return buildCSSText(m_leftSide->customCSSText(), m_rightSide->customCSSText(), m_operator);
     }
 
-    virtual bool equals(const CSSCalcExpressionNode& exp) const OVERRIDE
+    virtual bool equals(const CSSCalcExpressionNode& exp) const override
     {
         if (type() != exp.type())
             return false;
 
         const CSSCalcBinaryOperation& other = static_cast<const CSSCalcBinaryOperation&>(exp);
         return compareCSSValuePtr(m_leftSide, other.m_leftSide)
             && compareCSSValuePtr(m_rightSide, other.m_rightSide)
             && m_operator == other.m_operator;
     }
 
-    virtual Type type() const OVERRIDE { return CssCalcBinaryOperation; }
+    virtual Type type() const override { return CssCalcBinaryOperation; }
 
-    virtual CSSPrimitiveValue::UnitType primitiveType() const OVERRIDE
+    virtual CSSPrimitiveValue::UnitType primitiveType() const override
     {
         switch (m_category) {
         case CalcNumber:
             ASSERT(m_leftSide->category() == CalcNumber && m_rightSide->category() == CalcNumber);
             return CSSPrimitiveValue::CSS_NUMBER;
         case CalcLength:
         case CalcPercent: {
             if (m_leftSide->category() == CalcNumber)
                 return m_rightSide->primitiveType();
             if (m_rightSide->category() == CalcNumber)
@@ skipping 239 matching lines @@
     return adoptRefWillBeNoop(new CSSCalcValue(expression, range));
 }
 
 void CSSCalcValue::traceAfterDispatch(Visitor* visitor)
 {
     visitor->trace(m_expression);
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink