Oilpan: move SVG property hierarchy to the heap.

Source/core/svg/SVGTransformList.cpp

 /*
  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2012. 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
@@ skipping 17 matching lines @@
 #include "core/SVGNames.h"
 #include "core/svg/SVGAnimateTransformElement.h"
 #include "core/svg/SVGAnimatedNumber.h"
 #include "core/svg/SVGParserUtilities.h"
 #include "core/svg/SVGTransformDistance.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-inline PassRefPtr<SVGTransformList> toSVGTransformList(PassRefPtr<SVGPropertyBase> passBase)
+inline PassRefPtrWillBeRawPtr<SVGTransformList> toSVGTransformList(PassRefPtrWillBeRawPtr<SVGPropertyBase> passBase)
 {
-    RefPtr<SVGPropertyBase> base = passBase;
+    RefPtrWillBeRawPtr<SVGPropertyBase> base = passBase;
     ASSERT(base->type() == SVGTransformList::classType());
     return static_pointer_cast<SVGTransformList>(base.release());
 }
 
 SVGTransformList::SVGTransformList()
 {
 }
 
 SVGTransformList::~SVGTransformList()
 {
 }
 
-PassRefPtr<SVGTransform> SVGTransformList::consolidate()
+PassRefPtrWillBeRawPtr<SVGTransform> SVGTransformList::consolidate()
 {
     AffineTransform matrix;
     if (!concatenate(matrix))
         return SVGTransform::create();
 
-    RefPtr<SVGTransform> transform = SVGTransform::create(matrix);
+    RefPtrWillBeRawPtr<SVGTransform> transform = SVGTransform::create(matrix);
     clear();
     return appendItem(transform);
 }
 
 bool SVGTransformList::concatenate(AffineTransform& result) const
 {
     if (isEmpty())
         return false;
 
     ConstIterator it = begin();
@@ skipping 35 matching lines @@
         return -1;
 
     return parsedParams;
 }
 
 // These should be kept in sync with enum SVGTransformType
 static const int requiredValuesForType[] =  {0, 6, 1, 1, 1, 1, 1};
 static const int optionalValuesForType[] =  {0, 0, 1, 1, 2, 0, 0};
 
 template<typename CharType>
-PassRefPtr<SVGTransform> parseTransformOfType(unsigned type, const CharType*& ptr, const CharType* end)
+PassRefPtrWillBeRawPtr<SVGTransform> parseTransformOfType(unsigned type, const CharType*& ptr, const CharType* end)
 {
     if (type == SVG_TRANSFORM_UNKNOWN)
         return nullptr;
 
     int valueCount = 0;
     float values[] = {0, 0, 0, 0, 0, 0};
     if ((valueCount = parseTransformParamList(ptr, end, values, requiredValuesForType[type], optionalValuesForType[type])) < 0) {
         return nullptr;
     }
 
-    RefPtr<SVGTransform> transform = SVGTransform::create();
+    RefPtrWillBeRawPtr<SVGTransform> transform = SVGTransform::create();
 
     switch (type) {
     case SVG_TRANSFORM_SKEWX:
         transform->setSkewX(values[0]);
         break;
     case SVG_TRANSFORM_SKEWY:
         transform->setSkewY(values[0]);
         break;
     case SVG_TRANSFORM_SCALE:
         if (valueCount == 1) // Spec: if only one param given, assume uniform scaling
@@ skipping 34 matching lines @@
         SVGTransformType transformType = SVG_TRANSFORM_UNKNOWN;
         skipOptionalSVGSpaces(ptr, end);
 
         if (!parseAndSkipTransformType(ptr, end, transformType))
             return false;
 
         if (!skipOptionalSVGSpaces(ptr, end) || *ptr != '(')
             return false;
         ptr++;
 
-        RefPtr<SVGTransform> transform = parseTransformOfType(transformType, ptr, end);
+        RefPtrWillBeRawPtr<SVGTransform> transform = parseTransformOfType(transformType, ptr, end);
         if (!transform)
             return false;
 
         if (!skipOptionalSVGSpaces(ptr, end) || *ptr != ')')
             return false;
         ptr++;
 
         append(transform.release());
 
         skipOptionalSVGSpaces(ptr, end);
@@ skipping 50 matching lines @@
         const UChar* end = ptr + value.length();
         valid = parse(ptr, end);
     }
 
     if (!valid) {
         clear();
         exceptionState.throwDOMException(SyntaxError, "Problem parsing transform list=\""+value+"\"");
     }
 }
 
-PassRefPtr<SVGPropertyBase> SVGTransformList::cloneForAnimation(const String& value) const
+PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGTransformList::cloneForAnimation(const String& value) const
 {
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
-PassRefPtr<SVGTransformList> SVGTransformList::create(SVGTransformType transformType, const String& value)
+PassRefPtrWillBeRawPtr<SVGTransformList> SVGTransformList::create(SVGTransformType transformType, const String& value)
 {
-    RefPtr<SVGTransform> transform;
+    RefPtrWillBeRawPtr<SVGTransform> transform = nullptr;
     if (value.isEmpty()) {
     } else if (value.is8Bit()) {
         const LChar* ptr = value.characters8();
         const LChar* end = ptr + value.length();
         transform = parseTransformOfType(transformType, ptr, end);
     } else {
         const UChar* ptr = value.characters16();
         const UChar* end = ptr + value.length();
         transform = parseTransformOfType(transformType, ptr, end);
     }
 
-    RefPtr<SVGTransformList> svgTransformList = SVGTransformList::create();
+    RefPtrWillBeRawPtr<SVGTransformList> svgTransformList = SVGTransformList::create();
     if (transform)
         svgTransformList->append(transform);
     return svgTransformList.release();
 }
 
 void SVGTransformList::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement* contextElement)
 {
     if (isEmpty())
         return;
 
-    RefPtr<SVGTransformList> otherList = toSVGTransformList(other);
+    RefPtrWillBeRawPtr<SVGTransformList> otherList = toSVGTransformList(other);
     if (length() != otherList->length())
         return;
 
     ASSERT(length() == 1);
-    RefPtr<SVGTransform> fromTransform = at(0);
-    RefPtr<SVGTransform> toTransform = otherList->at(0);
+    RefPtrWillBeRawPtr<SVGTransform> fromTransform = at(0);
+    RefPtrWillBeRawPtr<SVGTransform> toTransform = otherList->at(0);
 
     ASSERT(fromTransform->transformType() == toTransform->transformType());
     clear();
     append(SVGTransformDistance::addSVGTransforms(fromTransform, toTransform));
 }
 
-void SVGTransformList::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtr<SVGPropertyBase> fromValue, PassRefPtr<SVGPropertyBase> toValue, PassRefPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
+void SVGTransformList::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
 {
     ASSERT(animationElement);
     bool isToAnimation = animationElement->animationMode() == ToAnimation;
 
     // Spec: To animations provide specific functionality to get a smooth change from the underlying value to the
     // ‘to’ attribute value, which conflicts mathematically with the requirement for additive transform animations
     // to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for ‘animateTransform’ is undefined
     // FIXME: This is not taken into account yet.
-    RefPtr<SVGTransformList> fromList = isToAnimation ? this : toSVGTransformList(fromValue);
-    RefPtr<SVGTransformList> toList = toSVGTransformList(toValue);
-    RefPtr<SVGTransformList> toAtEndOfDurationList = toSVGTransformList(toAtEndOfDurationValue);
+    RefPtrWillBeRawPtr<SVGTransformList> fromList = isToAnimation ? PassRefPtrWillBeRawPtr<SVGTransformList>(this) : toSVGTransformList(fromValue);
+    RefPtrWillBeRawPtr<SVGTransformList> toList = toSVGTransformList(toValue);
+    RefPtrWillBeRawPtr<SVGTransformList> toAtEndOfDurationList = toSVGTransformList(toAtEndOfDurationValue);
 
     size_t toListSize = toList->length();
     if (!toListSize)
         return;
 
     // Get a reference to the from value before potentially cleaning it out (in the case of a To animation.)
-    RefPtr<SVGTransform> toTransform = toList->at(0);
-    RefPtr<SVGTransform> effectiveFrom;
+    RefPtrWillBeRawPtr<SVGTransform> toTransform = toList->at(0);
+    RefPtrWillBeRawPtr<SVGTransform> effectiveFrom = nullptr;
     // If there's an existing 'from'/underlying value of the same type use that, else use a "zero transform".
     if (fromList->length() && fromList->at(0)->transformType() == toTransform->transformType())
         effectiveFrom = fromList->at(0);
     else
         effectiveFrom = SVGTransform::create(toTransform->transformType(), SVGTransform::ConstructZeroTransform);
 
     // Never resize the animatedTransformList to the toList size, instead either clear the list or append to it.
     if (!isEmpty() && (!animationElement->isAdditive() || isToAnimation))
         clear();
 
-    RefPtr<SVGTransform> currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
+    RefPtrWillBeRawPtr<SVGTransform> currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
     if (animationElement->isAccumulated() && repeatCount) {
-        RefPtr<SVGTransform> effectiveToAtEnd = !toAtEndOfDurationList->isEmpty() ? toAtEndOfDurationList->at(0) : SVGTransform::create(toTransform->transformType(), SVGTransform::ConstructZeroTransform);
+        RefPtrWillBeRawPtr<SVGTransform> effectiveToAtEnd = !toAtEndOfDurationList->isEmpty() ? PassRefPtrWillBeRawPtr<SVGTransform>(toAtEndOfDurationList->at(0)) : SVGTransform::create(toTransform->transformType(), SVGTransform::ConstructZeroTransform);
         append(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount));
     } else {
         append(currentTransform);
     }
 }
 
-float SVGTransformList::calculateDistance(PassRefPtr<SVGPropertyBase> toValue, SVGElement*)
+float SVGTransformList::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, SVGElement*)
 {
     // FIXME: This is not correct in all cases. The spec demands that each component (translate x and y for example)
     // is paced separately. To implement this we need to treat each component as individual animation everywhere.
 
-    RefPtr<SVGTransformList> toList = toSVGTransformList(toValue);
+    RefPtrWillBeRawPtr<SVGTransformList> toList = toSVGTransformList(toValue);
     if (isEmpty() || length() != toList->length())
         return -1;
 
     ASSERT(length() == 1);
     if (at(0)->transformType() == toList->at(0)->transformType())
         return -1;
 
     // Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances
     // Paced animations assume a notion of distance between the various animation values defined by the ‘to’, ‘from’, ‘by’ and ‘values’ attributes.
     // Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by ‘animateTransform’.
     return SVGTransformDistance(at(0), toList->at(0)).distance();
 }
 
 }