Oilpan: move SVG property hierarchy to the heap.

Source/core/svg/SVGSVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google, Inc.
  *
  * 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 81 matching lines @@
     // There are cases where removedFromDocument() is not called.
     // see ContainerNode::removeAllChildren, called by its destructor.
     // With Oilpan, either removedFrom is called or the document
     // is dead as well and there is no reason to clear the extensions.
     document().accessSVGExtensions().removeTimeContainer(this);
 
     ASSERT(inDocument() || !accessDocumentSVGExtensions().isSVGRootWithRelativeLengthDescendents(this));
 #endif
 }
 
-PassRefPtr<SVGRectTearOff> SVGSVGElement::viewport() const
+PassRefPtrWillBeRawPtr<SVGRectTearOff> SVGSVGElement::viewport() const
 {
     // FIXME: This method doesn't follow the spec and is basically untested. Parent documents are not considered here.
     // As we have no test coverage for this, we're going to disable it completly for now.
     return SVGRectTearOff::create(SVGRect::create(), 0, PropertyIsNotAnimVal);
 }
 
 float SVGSVGElement::pixelUnitToMillimeterX() const
 {
     return 1 / cssPixelsPerMillimeter;
 }
@@ skipping 52 matching lines @@
     // We choose the ignore this call, it's pretty useless to support calling setCurrentScale() from within
     // an embedded SVG document, for the same reasons as in currentScale() - needs resolution by SVG WG.
     if (frameTree.parent())
         return;
 
     frame->setPageZoomFactor(scale);
 }
 
 class SVGCurrentTranslateTearOff : public SVGPointTearOff {
 public:
-    static PassRefPtr<SVGCurrentTranslateTearOff> create(SVGSVGElement* contextElement)
+    static PassRefPtrWillBeRawPtr<SVGCurrentTranslateTearOff> create(SVGSVGElement* contextElement)
     {
-        return adoptRef(new SVGCurrentTranslateTearOff(contextElement));
+        return adoptRefWillBeNoop(new SVGCurrentTranslateTearOff(contextElement));
     }
 
     virtual void commitChange() override
     {
         ASSERT(contextElement());
         toSVGSVGElement(contextElement())->updateCurrentTranslate();
     }
 
 private:
     SVGCurrentTranslateTearOff(SVGSVGElement* contextElement)
         : SVGPointTearOff(contextElement->m_translation, contextElement, PropertyIsNotAnimVal)
     {
     }
 };
 
-PassRefPtr<SVGPointTearOff> SVGSVGElement::currentTranslateFromJavascript()
+PassRefPtrWillBeRawPtr<SVGPointTearOff> SVGSVGElement::currentTranslateFromJavascript()
 {
     return SVGCurrentTranslateTearOff::create(this);
 }
 
 void SVGSVGElement::setCurrentTranslate(const FloatPoint& point)
 {
     m_translation->setValue(point);
     updateCurrentTranslate();
 }
 
@@ skipping 37 matching lines @@
 bool SVGSVGElement::isPresentationAttribute(const QualifiedName& name) const
 {
     if (isOutermostSVGSVGElement() && (name == SVGNames::widthAttr || name == SVGNames::heightAttr))
         return true;
     return SVGGraphicsElement::isPresentationAttribute(name);
 }
 
 void SVGSVGElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
 {
     if (isOutermostSVGSVGElement() && (name == SVGNames::widthAttr || name == SVGNames::heightAttr)) {
-        RefPtr<SVGLength> length = SVGLength::create(LengthModeOther);
+        RefPtrWillBeRawPtr<SVGLength> length = SVGLength::create(LengthModeOther);
         TrackExceptionState exceptionState;
         length->setValueAsString(value, exceptionState);
         if (!exceptionState.hadException()) {
             if (name == SVGNames::widthAttr)
                 addPropertyToPresentationAttributeStyle(style, CSSPropertyWidth, value);
             else if (name == SVGNames::heightAttr)
                 addPropertyToPresentationAttributeStyle(style, CSSPropertyHeight, value);
         }
     } else {
         SVGGraphicsElement::collectStyleForPresentationAttribute(name, value, style);
@@ skipping 113 matching lines @@
     }
 
     for (SVGGraphicsElement& element : Traversal<SVGGraphicsElement>::descendantsOf(*root)) {
         if (checkIntersectionOrEnclosure(element, rect, mode))
             nodes.append(&element);
     }
 
     return StaticNodeList::adopt(nodes);
 }
 
-PassRefPtrWillBeRawPtr<StaticNodeList> SVGSVGElement::getIntersectionList(PassRefPtr<SVGRectTearOff> rect, SVGElement* referenceElement) const
+PassRefPtrWillBeRawPtr<StaticNodeList> SVGSVGElement::getIntersectionList(PassRefPtrWillBeRawPtr<SVGRectTearOff> rect, SVGElement* referenceElement) const
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     return collectIntersectionOrEnclosureList(rect->target()->value(), referenceElement, CheckIntersection);
 }
 
-PassRefPtrWillBeRawPtr<StaticNodeList> SVGSVGElement::getEnclosureList(PassRefPtr<SVGRectTearOff> rect, SVGElement* referenceElement) const
+PassRefPtrWillBeRawPtr<StaticNodeList> SVGSVGElement::getEnclosureList(PassRefPtrWillBeRawPtr<SVGRectTearOff> rect, SVGElement* referenceElement) const
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     return collectIntersectionOrEnclosureList(rect->target()->value(), referenceElement, CheckEnclosure);
 }
 
-bool SVGSVGElement::checkIntersection(SVGElement* element, PassRefPtr<SVGRectTearOff> rect) const
+bool SVGSVGElement::checkIntersection(SVGElement* element, PassRefPtrWillBeRawPtr<SVGRectTearOff> rect) const
 {
     ASSERT(element);
     document().updateLayoutIgnorePendingStylesheets();
 
     return checkIntersectionOrEnclosure(*element, rect->target()->value(), CheckIntersection);
 }
 
-bool SVGSVGElement::checkEnclosure(SVGElement* element, PassRefPtr<SVGRectTearOff> rect) const
+bool SVGSVGElement::checkEnclosure(SVGElement* element, PassRefPtrWillBeRawPtr<SVGRectTearOff> rect) const
 {
     ASSERT(element);
     document().updateLayoutIgnorePendingStylesheets();
 
     return checkIntersectionOrEnclosure(*element, rect->target()->value(), CheckEnclosure);
 }
 
 void SVGSVGElement::deselectAll()
 {
     if (LocalFrame* frame = document().frame())
         frame->selection().clear();
 }
 
-PassRefPtr<SVGNumberTearOff> SVGSVGElement::createSVGNumber()
+PassRefPtrWillBeRawPtr<SVGNumberTearOff> SVGSVGElement::createSVGNumber()
 {
     return SVGNumberTearOff::create(SVGNumber::create(0.0f), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGLengthTearOff> SVGSVGElement::createSVGLength()
+PassRefPtrWillBeRawPtr<SVGLengthTearOff> SVGSVGElement::createSVGLength()
 {
     return SVGLengthTearOff::create(SVGLength::create(), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGAngleTearOff> SVGSVGElement::createSVGAngle()
+PassRefPtrWillBeRawPtr<SVGAngleTearOff> SVGSVGElement::createSVGAngle()
 {
     return SVGAngleTearOff::create(SVGAngle::create(), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGPointTearOff> SVGSVGElement::createSVGPoint()
+PassRefPtrWillBeRawPtr<SVGPointTearOff> SVGSVGElement::createSVGPoint()
 {
     return SVGPointTearOff::create(SVGPoint::create(), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGMatrixTearOff> SVGSVGElement::createSVGMatrix()
+PassRefPtrWillBeRawPtr<SVGMatrixTearOff> SVGSVGElement::createSVGMatrix()
 {
     return SVGMatrixTearOff::create(AffineTransform());
 }
 
-PassRefPtr<SVGRectTearOff> SVGSVGElement::createSVGRect()
+PassRefPtrWillBeRawPtr<SVGRectTearOff> SVGSVGElement::createSVGRect()
 {
     return SVGRectTearOff::create(SVGRect::create(), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGTransformTearOff> SVGSVGElement::createSVGTransform()
+PassRefPtrWillBeRawPtr<SVGTransformTearOff> SVGSVGElement::createSVGTransform()
 {
     return SVGTransformTearOff::create(SVGTransform::create(SVG_TRANSFORM_MATRIX), 0, PropertyIsNotAnimVal);
 }
 
-PassRefPtr<SVGTransformTearOff> SVGSVGElement::createSVGTransformFromMatrix(PassRefPtr<SVGMatrixTearOff> matrix)
+PassRefPtrWillBeRawPtr<SVGTransformTearOff> SVGSVGElement::createSVGTransformFromMatrix(PassRefPtrWillBeRawPtr<SVGMatrixTearOff> matrix)
 {
     return SVGTransformTearOff::create(SVGTransform::create(matrix->value()), 0, PropertyIsNotAnimVal);
 }
 
 AffineTransform SVGSVGElement::localCoordinateSpaceTransform(SVGElement::CTMScope mode) const
 {
     AffineTransform viewBoxTransform;
     if (!hasEmptyViewBox()) {
         FloatSize size = currentViewportSize();
         viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
@@ skipping 184 matching lines @@
     SVGLengthContext lengthContext(this);
     return Length(height()->currentValue()->value(lengthContext), Fixed);
 }
 
 AffineTransform SVGSVGElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
 {
     if (!m_useCurrentView || !m_viewSpec)
         return SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), preserveAspectRatio()->currentValue(), viewWidth, viewHeight);
 
     AffineTransform ctm = SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), m_viewSpec->preserveAspectRatio()->currentValue(), viewWidth, viewHeight);
-    RefPtr<SVGTransformList> transformList = m_viewSpec->transform();
+    RefPtrWillBeRawPtr<SVGTransformList> transformList = m_viewSpec->transform();
     if (transformList->isEmpty())
         return ctm;
 
     AffineTransform transform;
     if (transformList->concatenate(transform))
         ctm *= transform;
 
     return ctm;
 }
 
@@ skipping 79 matching lines @@
     if (isOutermostSVGSVGElement())
         return;
 
     // finishParsingChildren() is called when the close tag is reached for an element (e.g. </svg>)
     // we send SVGLoad events here if we can, otherwise they'll be sent when any required loads finish
     sendSVGLoadEventIfPossible();
 }
 
 void SVGSVGElement::trace(Visitor* visitor)
 {
+    visitor->trace(m_x);
+    visitor->trace(m_y);
+    visitor->trace(m_width);
+    visitor->trace(m_height);
+    visitor->trace(m_translation);
     visitor->trace(m_timeContainer);
     visitor->trace(m_viewSpec);
     SVGGraphicsElement::trace(visitor);
+    SVGFitToViewBox::trace(visitor);
 }
 
 } // namespace blink