Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/svg/RenderSVGText.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
  * Copyright (C) 2012 Google Inc.
  *
@@ skipping 49 matching lines @@
     , m_needsTransformUpdate(true)
     , m_needsTextMetricsUpdate(false)
 {
 }
 
 RenderSVGText::~RenderSVGText()
 {
     ASSERT(m_layoutAttributes.isEmpty());
 }
 
-bool RenderSVGText::isChildAllowed(RenderObject* child, const RenderStyle&) const
+bool RenderSVGText::isChildAllowed(LayoutObject* child, const RenderStyle&) const
 {
     return child->isSVGInline() || (child->isText() && SVGRenderSupport::isRenderableTextNode(child));
 }
 
-RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(RenderObject* start)
+RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(LayoutObject* start)
 {
     ASSERT(start);
     while (start && !start->isSVGText())
         start = start->parent();
     if (!start || !start->isSVGText())
         return 0;
     return toRenderSVGText(start);
 }
 
-const RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(const RenderObject* start)
+const RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(const LayoutObject* start)
 {
     ASSERT(start);
     while (start && !start->isSVGText())
         start = start->parent();
     if (!start || !start->isSVGText())
         return 0;
     return toRenderSVGText(start);
 }
 
-static inline void collectLayoutAttributes(RenderObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
+static inline void collectLayoutAttributes(LayoutObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
 {
-    for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
+    for (LayoutObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
         if (descendant->isSVGInlineText())
             attributes.append(toRenderSVGInlineText(descendant)->layoutAttributes());
     }
 }
 
 static inline bool findPreviousAndNextAttributes(RenderSVGText* root, RenderSVGInlineText* locateElement, SVGTextLayoutAttributes*& previous, SVGTextLayoutAttributes*& next)
 {
     ASSERT(root);
     ASSERT(locateElement);
     bool stopAfterNext = false;
-    RenderObject* current = root->firstChild();
+    LayoutObject* current = root->firstChild();
     while (current) {
         if (current->isSVGInlineText()) {
             RenderSVGInlineText* text = toRenderSVGInlineText(current);
             if (locateElement != text) {
                 if (stopAfterNext) {
                     next = text->layoutAttributes();
                     return true;
                 }
 
                 previous = text->layoutAttributes();
             } else {
                 stopAfterNext = true;
             }
         } else if (current->isSVGInline()) {
             // Descend into text content (if possible).
-            if (RenderObject* child = toRenderSVGInline(current)->firstChild()) {
+            if (LayoutObject* child = toRenderSVGInline(current)->firstChild()) {
                 current = child;
                 continue;
             }
         }
 
         current = current->nextInPreOrderAfterChildren(root);
     }
     return false;
 }
 
 inline bool RenderSVGText::shouldHandleSubtreeMutations() const
 {
     if (beingDestroyed() || !everHadLayout()) {
         ASSERT(m_layoutAttributes.isEmpty());
         ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
         return false;
     }
     return true;
 }
 
-void RenderSVGText::subtreeChildWasAdded(RenderObject* child)
+void RenderSVGText::subtreeChildWasAdded(LayoutObject* child)
 {
     ASSERT(child);
     if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
         return;
 
     // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
     FontCachePurgePreventer fontCachePurgePreventer;
 
     // The positioning elements cache doesn't include the new 'child' yet. Clear the
     // cache, as the next buildLayoutAttributesForTextRenderer() call rebuilds it.
@@ skipping 50 matching lines @@
 }
 
 void RenderSVGText::willBeDestroyed()
 {
     m_layoutAttributes.clear();
     m_layoutAttributesBuilder.clearTextPositioningElements();
 
     RenderSVGBlock::willBeDestroyed();
 }
 
-void RenderSVGText::subtreeChildWillBeRemoved(RenderObject* child, Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
+void RenderSVGText::subtreeChildWillBeRemoved(LayoutObject* child, Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
 {
     ASSERT(child);
     if (!shouldHandleSubtreeMutations())
         return;
 
     checkLayoutAttributesConsistency(this, m_layoutAttributes);
 
     // The positioning elements cache depends on the size of each text renderer in the
     // subtree. If this changes, clear the cache. It's going to be rebuilt below.
     m_layoutAttributesBuilder.clearTextPositioningElements();
@@ skipping 34 matching lines @@
 void RenderSVGText::subtreeStyleDidChange()
 {
     if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
         return;
 
     checkLayoutAttributesConsistency(this, m_layoutAttributes);
 
     // Only update the metrics cache, but not the text positioning element cache
     // nor the layout attributes cached in the leaf #text renderers.
     FontCachePurgePreventer fontCachePurgePreventer;
-    for (RenderObject* descendant = firstChild(); descendant; descendant = descendant->nextInPreOrder(this)) {
+    for (LayoutObject* descendant = firstChild(); descendant; descendant = descendant->nextInPreOrder(this)) {
         if (descendant->isSVGInlineText())
             m_layoutAttributesBuilder.rebuildMetricsForTextRenderer(toRenderSVGInlineText(descendant));
     }
 }
 
 void RenderSVGText::subtreeTextDidChange(RenderSVGInlineText* text)
 {
     ASSERT(text);
     ASSERT(!beingDestroyed());
     if (!everHadLayout()) {
         ASSERT(m_layoutAttributes.isEmpty());
         ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
         return;
     }
 
     // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
     FontCachePurgePreventer fontCachePurgePreventer;
 
     // The positioning elements cache depends on the size of each text renderer in the
     // subtree. If this changes, clear the cache. It's going to be rebuilt below.
     m_layoutAttributesBuilder.clearTextPositioningElements();
 
     checkLayoutAttributesConsistency(this, m_layoutAttributes);
-    for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
+    for (LayoutObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
         if (descendant->isSVGInlineText())
             m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(toRenderSVGInlineText(descendant));
     }
 }
 
-static inline void updateFontInAllDescendants(RenderObject* start, SVGTextLayoutAttributesBuilder* builder = 0)
+static inline void updateFontInAllDescendants(LayoutObject* start, SVGTextLayoutAttributesBuilder* builder = 0)
 {
-    for (RenderObject* descendant = start; descendant; descendant = descendant->nextInPreOrder(start)) {
+    for (LayoutObject* descendant = start; descendant; descendant = descendant->nextInPreOrder(start)) {
         if (!descendant->isSVGInlineText())
             continue;
         RenderSVGInlineText* text = toRenderSVGInlineText(descendant);
         text->updateScaledFont();
         if (builder)
             builder->rebuildMetricsForTextRenderer(text);
     }
 }
 
 void RenderSVGText::layout()
@@ skipping 165 matching lines @@
 {
     FloatRect paintInvalidationRect = strokeBoundingBox();
     SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, paintInvalidationRect);
 
     if (const ShadowList* textShadow = style()->textShadow())
         textShadow->adjustRectForShadow(paintInvalidationRect);
 
     return paintInvalidationRect;
 }
 
-void RenderSVGText::addChild(RenderObject* child, RenderObject* beforeChild)
+void RenderSVGText::addChild(LayoutObject* child, LayoutObject* beforeChild)
 {
     RenderSVGBlock::addChild(child, beforeChild);
 
     SVGResourcesCache::clientWasAddedToTree(child, child->style());
     subtreeChildWasAdded(child);
 }
 
-void RenderSVGText::removeChild(RenderObject* child)
+void RenderSVGText::removeChild(LayoutObject* child)
 {
     SVGResourcesCache::clientWillBeRemovedFromTree(child);
 
     Vector<SVGTextLayoutAttributes*, 2> affectedAttributes;
     FontCachePurgePreventer fontCachePurgePreventer;
     subtreeChildWillBeRemoved(child, affectedAttributes);
     RenderSVGBlock::removeChild(child);
     subtreeChildWasRemoved(affectedAttributes);
 }
 
 }