Oilpan: move SVG property hierarchy to the heap.

Source/core/svg/SVGAngle.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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 40 matching lines @@
 SVGMarkerOrientEnumeration::SVGMarkerOrientEnumeration(SVGAngle* angle)
     : SVGEnumeration<SVGMarkerOrientType>(SVGMarkerOrientAngle)
     , m_angle(angle)
 {
 }
 
 SVGMarkerOrientEnumeration::~SVGMarkerOrientEnumeration()
 {
 }
 
+void SVGMarkerOrientEnumeration::trace(Visitor* visitor)
+{
+    visitor->trace(m_angle);
+    SVGEnumeration<SVGMarkerOrientType>::trace(visitor);
+}
+
 void SVGMarkerOrientEnumeration::notifyChange()
 {
     ASSERT(m_angle);
     m_angle->orientTypeChanged();
 }
 
 void SVGMarkerOrientEnumeration::add(PassRefPtrWillBeRawPtr<SVGPropertyBase>, SVGElement*)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
 }
 
-void SVGMarkerOrientEnumeration::calculateAnimatedValue(SVGAnimationElement*, float percentage, unsigned repeatCount, PassRefPtr<SVGPropertyBase> from, PassRefPtr<SVGPropertyBase> to, PassRefPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
+void SVGMarkerOrientEnumeration::calculateAnimatedValue(SVGAnimationElement*, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> from, PassRefPtrWillBeRawPtr<SVGPropertyBase> to, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
 }
 
-float SVGMarkerOrientEnumeration::calculateDistance(PassRefPtr<SVGPropertyBase> to, SVGElement* contextElement)
+float SVGMarkerOrientEnumeration::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> to, SVGElement* contextElement)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
     return -1.0;
 }
 
 SVGAngle::SVGAngle()
     : m_unitType(SVG_ANGLETYPE_UNSPECIFIED)
     , m_valueInSpecifiedUnits(0)
     , m_orientType(SVGMarkerOrientEnumeration::create(this))
 {
 }
 
 SVGAngle::SVGAngle(SVGAngleType unitType, float valueInSpecifiedUnits, SVGMarkerOrientType orientType)
     : m_unitType(unitType)
     , m_valueInSpecifiedUnits(valueInSpecifiedUnits)
     , m_orientType(SVGMarkerOrientEnumeration::create(this))
 {
     m_orientType->setEnumValue(orientType);
 }
 
 SVGAngle::~SVGAngle()
 {
 }
 
-PassRefPtr<SVGAngle> SVGAngle::clone() const
+void SVGAngle::trace(Visitor* visitor)
 {
-    return adoptRef(new SVGAngle(m_unitType, m_valueInSpecifiedUnits, m_orientType->enumValue()));
+    visitor->trace(m_orientType);
+    SVGPropertyHelper<SVGAngle>::trace(visitor);
+}
+
+PassRefPtrWillBeRawPtr<SVGAngle> SVGAngle::clone() const
+{
+    return adoptRefWillBeNoop(new SVGAngle(m_unitType, m_valueInSpecifiedUnits, m_orientType->enumValue()));
 }
 
 float SVGAngle::value() const
 {
     switch (m_unitType) {
     case SVG_ANGLETYPE_GRAD:
         return grad2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_RAD:
         return rad2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_TURN:
@@ skipping 237 matching lines @@
         ASSERT_NOT_REACHED();
         break;
     }
 
     m_unitType = unitType;
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
 }
 
 void SVGAngle::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement*)
 {
-    RefPtr<SVGAngle> otherAngle = toSVGAngle(other);
+    RefPtrWillBeRawPtr<SVGAngle> otherAngle = toSVGAngle(other);
 
     // Only respect by animations, if from and by are both specified in angles (and not eg. 'auto').
     if (orientType()->enumValue() != SVGMarkerOrientAngle || otherAngle->orientType()->enumValue() != SVGMarkerOrientAngle)
         return;
 
     setValue(value() + otherAngle->value());
 }
 
 void SVGAngle::assign(const SVGAngle& other)
 {
     SVGMarkerOrientType otherOrientType = other.orientType()->enumValue();
     if (otherOrientType == SVGMarkerOrientAngle)
         newValueSpecifiedUnits(other.unitType(), other.valueInSpecifiedUnits());
     else
         m_orientType->setEnumValue(otherOrientType);
 }
 
-void SVGAngle::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtr<SVGPropertyBase> from, PassRefPtr<SVGPropertyBase> to, PassRefPtr<SVGPropertyBase> toAtEndOfDuration, SVGElement*)
+void SVGAngle::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> from, PassRefPtrWillBeRawPtr<SVGPropertyBase> to, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDuration, SVGElement*)
 {
     ASSERT(animationElement);
     bool isToAnimation = animationElement->animationMode() == ToAnimation;
 
-    RefPtr<SVGAngle> fromAngle = isToAnimation ? this : toSVGAngle(from);
-    RefPtr<SVGAngle> toAngle = toSVGAngle(to);
+    RefPtrWillBeRawPtr<SVGAngle> fromAngle = isToAnimation ? PassRefPtrWillBeRawPtr<SVGAngle>(this) : toSVGAngle(from);
+    RefPtrWillBeRawPtr<SVGAngle> toAngle = toSVGAngle(to);
     SVGMarkerOrientType fromOrientType = fromAngle->orientType()->enumValue();
     SVGMarkerOrientType toOrientType = toAngle->orientType()->enumValue();
 
     if (fromOrientType != toOrientType) {
         // Fall back to discrete animation.
         assign(percentage < 0.5f ? *fromAngle : *toAngle);
         return;
     }
 
     switch (fromOrientType) {
     // From 'auto' to 'auto', or 'auto-start-reverse' to 'auto-start-reverse'
     case SVGMarkerOrientAuto:
     case SVGMarkerOrientAutoStartReverse:
         orientType()->setEnumValue(fromOrientType);
         return;
 
     // Regular from angle to angle animation, with all features like additive etc.
     case SVGMarkerOrientAngle:
         {
             float animatedValue = value();
-            RefPtr<SVGAngle> toAtEndOfDurationAngle = toSVGAngle(toAtEndOfDuration);
+            RefPtrWillBeRawPtr<SVGAngle> toAtEndOfDurationAngle = toSVGAngle(toAtEndOfDuration);
 
             animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngle->value(), toAngle->value(), toAtEndOfDurationAngle->value(), animatedValue);
             orientType()->setEnumValue(SVGMarkerOrientAngle);
             setValue(animatedValue);
         }
         return;
 
     // If the enumeration value is not angle or auto, its unknown.
     default:
         m_valueInSpecifiedUnits = 0;
         orientType()->setEnumValue(SVGMarkerOrientUnknown);
         return;
     }
 }
 
-float SVGAngle::calculateDistance(PassRefPtr<SVGPropertyBase> other, SVGElement*)
+float SVGAngle::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement*)
 {
     return fabsf(value() - toSVGAngle(other)->value());
 }
 
 void SVGAngle::orientTypeChanged()
 {
     if (orientType()->enumValue() == SVGMarkerOrientAuto || orientType()->enumValue() == SVGMarkerOrientAutoStartReverse) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 }