Oilpan: move RenderObjects off heap.

Source/core/rendering/svg/RenderSVGResourcePattern.cpp

 /*
  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright 2014 The Chromium Authors. 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 25 matching lines @@
 struct PatternData {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     RefPtr<Pattern> pattern;
     AffineTransform transform;
 };
 
 RenderSVGResourcePattern::RenderSVGResourcePattern(SVGPatternElement* node)
     : RenderSVGResourcePaintServer(node)
     , m_shouldCollectPatternAttributes(true)
+#if ENABLE(OILPAN)
+    , m_attributesWrapper(PatternAttributesWrapper::create())
+#endif
 {
 }
 
-void RenderSVGResourcePattern::trace(Visitor* visitor)
-{
-    visitor->trace(m_attributes);
-    RenderSVGResourcePaintServer::trace(visitor);
-}
-
 void RenderSVGResourcePattern::removeAllClientsFromCache(bool markForInvalidation)
 {
     m_patternMap.clear();
     m_shouldCollectPatternAttributes = true;
     markAllClientsForInvalidation(markForInvalidation ? PaintInvalidation : ParentOnlyInvalidation);
 }
 
 void RenderSVGResourcePattern::removeClientFromCache(RenderObject* client, bool markForInvalidation)
 {
     ASSERT(client);
@@ skipping 10 matching lines @@
     // Hopefully that will be addressed at some point, and then we can optimize the lookup.
     if (PatternData* currentData = m_patternMap.get(&object))
         return currentData;
 
     return m_patternMap.set(&object, buildPatternData(object)).storedValue->value.get();
 }
 
 PassOwnPtr<PatternData> RenderSVGResourcePattern::buildPatternData(const RenderObject& object)
 {
     // If we couldn't determine the pattern content element root, stop here.
-    if (!m_attributes.patternContentElement())
+    const PatternAttributes& attributes = this->attributes();
+    if (!attributes.patternContentElement())
         return nullptr;
 
     // An empty viewBox disables rendering.
-    if (m_attributes.hasViewBox() && m_attributes.viewBox().isEmpty())
+    if (attributes.hasViewBox() && attributes.viewBox().isEmpty())
         return nullptr;
 
     ASSERT(element());
     // Compute tile metrics.
     FloatRect clientBoundingBox = object.objectBoundingBox();
     FloatRect tileBounds = SVGLengthContext::resolveRectangle(element(),
-        m_attributes.patternUnits(), clientBoundingBox,
-        m_attributes.x(), m_attributes.y(), m_attributes.width(), m_attributes.height());
+        attributes.patternUnits(), clientBoundingBox,
+        attributes.x(), attributes.y(), attributes.width(), attributes.height());
     if (tileBounds.isEmpty())
         return nullptr;
 
     AffineTransform tileTransform;
-    if (m_attributes.hasViewBox()) {
-        if (m_attributes.viewBox().isEmpty())
+    if (attributes.hasViewBox()) {
+        if (attributes.viewBox().isEmpty())
             return nullptr;
-        tileTransform = SVGFitToViewBox::viewBoxToViewTransform(m_attributes.viewBox(),
-            m_attributes.preserveAspectRatio(), tileBounds.width(), tileBounds.height());
+        tileTransform = SVGFitToViewBox::viewBoxToViewTransform(attributes.viewBox(),
+            attributes.preserveAspectRatio(), tileBounds.width(), tileBounds.height());
     } else {
         // A viewbox overrides patternContentUnits, per spec.
-        if (m_attributes.patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+        if (attributes.patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
             tileTransform.scale(clientBoundingBox.width(), clientBoundingBox.height());
     }
 
     OwnPtr<PatternData> patternData = adoptPtr(new PatternData);
     patternData->pattern = Pattern::createPicturePattern(asPicture(tileBounds, tileTransform));
 
     // Compute pattern space transformation.
     patternData->transform.translate(tileBounds.x(), tileBounds.y());
-    AffineTransform patternTransform = m_attributes.patternTransform();
+    AffineTransform patternTransform = attributes.patternTransform();
     if (!patternTransform.isIdentity())
         patternData->transform = patternTransform * patternData->transform;
 
     return patternData.release();
 }
 
 SVGPaintServer RenderSVGResourcePattern::preparePaintServer(const RenderObject& object)
 {
     clearInvalidationMask();
 
     SVGPatternElement* patternElement = toSVGPatternElement(element());
     if (!patternElement)
         return SVGPaintServer::invalid();
 
     if (m_shouldCollectPatternAttributes) {
         patternElement->synchronizeAnimatedSVGAttribute(anyQName());
 
+#if ENABLE(OILPAN)
+        m_attributesWrapper->set(PatternAttributes());
+#else
         m_attributes = PatternAttributes();
-        patternElement->collectPatternAttributes(m_attributes);
+#endif
+        patternElement->collectPatternAttributes(mutableAttributes());
         m_shouldCollectPatternAttributes = false;
     }
 
     // Spec: When the geometry of the applicable element has no width or height and objectBoundingBox is specified,
     // then the given effect (e.g. a gradient or a filter) will be ignored.
     FloatRect objectBoundingBox = object.objectBoundingBox();
-    if (m_attributes.patternUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX && objectBoundingBox.isEmpty())
+    if (attributes().patternUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX && objectBoundingBox.isEmpty())
         return SVGPaintServer::invalid();
 
     PatternData* patternData = patternForRenderer(object);
     if (!patternData || !patternData->pattern)
         return SVGPaintServer::invalid();
 
     patternData->pattern->setPatternSpaceTransform(patternData->transform);
 
     return SVGPaintServer(patternData->pattern);
 }
 
 PassRefPtr<const SkPicture> RenderSVGResourcePattern::asPicture(const FloatRect& tileBounds,
     const AffineTransform& tileTransform) const
 {
     ASSERT(!m_shouldCollectPatternAttributes);
 
     AffineTransform contentTransform;
-    if (m_attributes.patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+    if (attributes().patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
         contentTransform = tileTransform;
 
     // Draw the content into a Picture.
     OwnPtr<DisplayItemList> displayItemList;
     if (RuntimeEnabledFeatures::slimmingPaintEnabled())
         displayItemList = DisplayItemList::create();
     GraphicsContext recordingContext(nullptr, displayItemList.get());
     recordingContext.beginRecording(FloatRect(FloatPoint(), tileBounds.size()));
 
-    ASSERT(m_attributes.patternContentElement());
+    ASSERT(attributes().patternContentElement());
     RenderSVGResourceContainer* patternRenderer =
-        toRenderSVGResourceContainer(m_attributes.patternContentElement()->renderer());
+        toRenderSVGResourceContainer(attributes().patternContentElement()->renderer());
     ASSERT(patternRenderer);
     ASSERT(!patternRenderer->needsLayout());
 
     SubtreeContentTransformScope contentTransformScope(contentTransform);
 
     {
         TransformRecorder transformRecorder(recordingContext, patternRenderer->displayItemClient(), tileTransform);
         for (RenderObject* child = patternRenderer->firstChild(); child; child = child->nextSibling())
             SVGRenderingContext::renderSubtree(&recordingContext, child);
     }
 
     if (displayItemList)
         displayItemList->replay(&recordingContext);
     return recordingContext.endRecording();
 }
 
 }