Oilpan: move SVG property hierarchy to the heap.

Source/core/svg/SVGLength.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 112 matching lines @@
 }
 
 SVGLength::SVGLength(const SVGLength& o)
     : SVGPropertyBase(classType())
     , m_valueInSpecifiedUnits(o.m_valueInSpecifiedUnits)
     , m_unitMode(o.m_unitMode)
     , m_unitType(o.m_unitType)
 {
 }
 
-PassRefPtr<SVGLength> SVGLength::clone() const
+PassRefPtrWillBeRawPtr<SVGLength> SVGLength::clone() const
 {
-    return adoptRef(new SVGLength(*this));
+    return adoptRefWillBeNoop(new SVGLength(*this));
 }
 
-PassRefPtr<SVGPropertyBase> SVGLength::cloneForAnimation(const String& value) const
+PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGLength::cloneForAnimation(const String& value) const
 {
-    RefPtr<SVGLength> length = create();
+    RefPtrWillBeRawPtr<SVGLength> length = create();
 
     length->m_unitMode = m_unitMode;
     length->m_unitType = m_unitType;
 
     TrackExceptionState exceptionState;
     length->setValueAsString(value, exceptionState);
     if (exceptionState.hadException()) {
         length->m_unitType = LengthTypeNumber;
         length->m_valueInSpecifiedUnits = 0;
     }
@@ skipping 104 matching lines @@
     SVGLengthType originalType = unitType();
     m_unitType = type;
     setValue(valueInUserUnits, context, exceptionState);
     if (!exceptionState.hadException())
         return;
 
     // Eventually restore old unit and type
     m_unitType = originalType;
 }
 
-PassRefPtr<SVGLength> SVGLength::fromCSSPrimitiveValue(CSSPrimitiveValue* value)
+PassRefPtrWillBeRawPtr<SVGLength> SVGLength::fromCSSPrimitiveValue(CSSPrimitiveValue* value)
 {
     ASSERT(value);
 
     SVGLengthType svgType;
     switch (value->primitiveType()) {
     case CSSPrimitiveValue::CSS_NUMBER:
         svgType = LengthTypeNumber;
         break;
     case CSSPrimitiveValue::CSS_PERCENTAGE:
         svgType = LengthTypePercentage;
@@ skipping 18 matching lines @@
         break;
     case CSSPrimitiveValue::CSS_PT:
         svgType = LengthTypePT;
         break;
     default:
         ASSERT(value->primitiveType() == CSSPrimitiveValue::CSS_PC);
         svgType = LengthTypePC;
         break;
     };
 
-    RefPtr<SVGLength> length = SVGLength::create();
+    RefPtrWillBeRawPtr<SVGLength> length = SVGLength::create();
     length->newValueSpecifiedUnits(svgType, value->getFloatValue());
     return length.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> SVGLength::toCSSPrimitiveValue(PassRefPtr<SVGLength> passLength)
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> SVGLength::toCSSPrimitiveValue(PassRefPtrWillBeRawPtr<SVGLength> passLength)
 {
-    RefPtr<SVGLength> length = passLength;
+    RefPtrWillBeRawPtr<SVGLength> length = passLength;
 
     CSSPrimitiveValue::UnitType cssType = CSSPrimitiveValue::CSS_UNKNOWN;
     switch (length->unitType()) {
     case LengthTypeUnknown:
         break;
     case LengthTypeNumber:
         cssType = CSSPrimitiveValue::CSS_NUMBER;
         break;
     case LengthTypePercentage:
         cssType = CSSPrimitiveValue::CSS_PERCENTAGE;
@@ skipping 57 matching lines @@
         s_lengthModeMap.set(SVGNames::textLengthAttr, LengthModeWidth);
         s_lengthModeMap.set(SVGNames::startOffsetAttr, LengthModeWidth);
     }
 
     if (s_lengthModeMap.contains(attrName))
         return s_lengthModeMap.get(attrName);
 
     return LengthModeOther;
 }
 
-PassRefPtr<SVGLength> SVGLength::blend(PassRefPtr<SVGLength> passFrom, float progress) const
+PassRefPtrWillBeRawPtr<SVGLength> SVGLength::blend(PassRefPtrWillBeRawPtr<SVGLength> passFrom, float progress) const
 {
-    RefPtr<SVGLength> from = passFrom;
+    RefPtrWillBeRawPtr<SVGLength> from = passFrom;
 
     SVGLengthType toType = unitType();
     SVGLengthType fromType = from->unitType();
     if ((from->isZero() && isZero())
         || fromType == LengthTypeUnknown
         || toType == LengthTypeUnknown
         || (!from->isZero() && fromType != LengthTypePercentage && toType == LengthTypePercentage)
         || (!isZero() && fromType == LengthTypePercentage && toType != LengthTypePercentage)
         || (!from->isZero() && !isZero() && (fromType == LengthTypeEMS || fromType == LengthTypeEXS) && fromType != toType))
         return clone();
 
-    RefPtr<SVGLength> length = create();
+    RefPtrWillBeRawPtr<SVGLength> length = create();
 
     if (fromType == LengthTypePercentage || toType == LengthTypePercentage) {
         float fromPercent = from->valueAsPercentage() * 100;
         float toPercent = valueAsPercentage() * 100;
         length->newValueSpecifiedUnits(LengthTypePercentage, blink::blend(fromPercent, toPercent, progress));
         return length;
     }
 
     if (fromType == toType || from->isZero() || isZero() || fromType == LengthTypeEMS || fromType == LengthTypeEXS) {
         float fromValue = from->valueInSpecifiedUnits();
@@ skipping 23 matching lines @@
     return length;
 }
 
 void SVGLength::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement* contextElement)
 {
     SVGLengthContext lengthContext(contextElement);
 
     setValue(value(lengthContext) + toSVGLength(other)->value(lengthContext), lengthContext, ASSERT_NO_EXCEPTION);
 }
 
-void SVGLength::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtr<SVGPropertyBase> fromValue, PassRefPtr<SVGPropertyBase> toValue, PassRefPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
+void SVGLength::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
 {
-    RefPtr<SVGLength> fromLength = toSVGLength(fromValue);
-    RefPtr<SVGLength> toLength = toSVGLength(toValue);
-    RefPtr<SVGLength> toAtEndOfDurationLength = toSVGLength(toAtEndOfDurationValue);
+    RefPtrWillBeRawPtr<SVGLength> fromLength = toSVGLength(fromValue);
+    RefPtrWillBeRawPtr<SVGLength> toLength = toSVGLength(toValue);
+    RefPtrWillBeRawPtr<SVGLength> toAtEndOfDurationLength = toSVGLength(toAtEndOfDurationValue);
 
     SVGLengthContext lengthContext(contextElement);
     float animatedNumber = value(lengthContext, IGNORE_EXCEPTION);
     animationElement->animateAdditiveNumber(percentage, repeatCount, fromLength->value(lengthContext, IGNORE_EXCEPTION), toLength->value(lengthContext, IGNORE_EXCEPTION), toAtEndOfDurationLength->value(lengthContext, IGNORE_EXCEPTION), animatedNumber);
 
     ASSERT(unitMode() == lengthModeForAnimatedLengthAttribute(animationElement->attributeName()));
     m_unitType = percentage < 0.5 ? fromLength->unitType() : toLength->unitType();
     setValue(animatedNumber, lengthContext, ASSERT_NO_EXCEPTION);
 }
 
-float SVGLength::calculateDistance(PassRefPtr<SVGPropertyBase> toValue, SVGElement* contextElement)
+float SVGLength::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, SVGElement* contextElement)
 {
     SVGLengthContext lengthContext(contextElement);
-    RefPtr<SVGLength> toLength = toSVGLength(toValue);
+    RefPtrWillBeRawPtr<SVGLength> toLength = toSVGLength(toValue);
 
     return fabsf(toLength->value(lengthContext, IGNORE_EXCEPTION) - value(lengthContext, IGNORE_EXCEPTION));
 }
 
 }