Remove the LayoutSVGInlineText* context in SVGTextLayoutAttributes

third_party/WebKit/Source/core/layout/svg/LayoutSVGText.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 13 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/layout/svg/LayoutSVGText.h"
 
 #include "core/editing/PositionWithAffinity.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutAnalyzer.h"
 #include "core/layout/LayoutState.h"
-#include "core/layout/LayoutView.h"
 #include "core/layout/PointerEventsHitRules.h"
 #include "core/layout/api/LineLayoutItem.h"
 #include "core/layout/svg/LayoutSVGInline.h"
 #include "core/layout/svg/LayoutSVGInlineText.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/layout/svg/SVGTextLayoutAttributesBuilder.h"
 #include "core/layout/svg/line/SVGRootInlineBox.h"
 #include "core/paint/SVGTextPainter.h"
 #include "core/style/ShadowList.h"
-#include "core/svg/SVGLengthList.h"
 #include "core/svg/SVGTextElement.h"
-#include "core/svg/SVGTransformList.h"
-#include "core/svg/SVGURIReference.h"
 #include "platform/FloatConversion.h"
 #include "platform/geometry/FloatQuad.h"
 
 namespace blink {
 
 namespace {
 
 const LayoutSVGText* findTextRoot(const LayoutObject* start)
 {
     ASSERT(start);
@@ skipping 10 matching lines @@
     : LayoutSVGBlock(node)
     , m_needsReordering(false)
     , m_needsPositioningValuesUpdate(false)
     , m_needsTransformUpdate(true)
     , m_needsTextMetricsUpdate(false)
 {
 }
 
 LayoutSVGText::~LayoutSVGText()
 {
-    ASSERT(m_layoutAttributes.isEmpty());
+    ASSERT(m_descendantTextNodes.isEmpty());
 }
 
 void LayoutSVGText::willBeDestroyed()
 {
-    m_layoutAttributes.clear();
+    m_descendantTextNodes.clear();
 
     LayoutSVGBlock::willBeDestroyed();
 }
 
 bool LayoutSVGText::isChildAllowed(LayoutObject* child, const ComputedStyle&) const
 {
     return child->isSVGInline() || (child->isText() && SVGLayoutSupport::isLayoutableTextNode(child));
 }
 
 LayoutSVGText* LayoutSVGText::locateLayoutSVGTextAncestor(LayoutObject* start)
 {
     return const_cast<LayoutSVGText*>(findTextRoot(start));
 }
 
 const LayoutSVGText* LayoutSVGText::locateLayoutSVGTextAncestor(const LayoutObject* start)
 {
     return findTextRoot(start);
 }
 
-static inline void collectLayoutAttributes(LayoutObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
+static inline void collectDescendantTextNodes(LayoutSVGText& textRoot, Vector<LayoutSVGInlineText*>& descendantTextNodes)
 {
-    for (LayoutObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
+    for (LayoutObject* descendant = textRoot.firstChild(); descendant; descendant = descendant->nextInPreOrder(&textRoot)) {
         if (descendant->isSVGInlineText())
-            attributes.append(toLayoutSVGInlineText(descendant)->layoutAttributes());
+            descendantTextNodes.append(toLayoutSVGInlineText(descendant));
     }
 }
 
 void LayoutSVGText::invalidatePositioningValues(LayoutInvalidationReasonForTracing reason)
 {
-    m_layoutAttributes.clear();
+    m_descendantTextNodes.clear();
     setNeedsPositioningValuesUpdate();
     setNeedsLayoutAndFullPaintInvalidation(reason);
 }
 
 void LayoutSVGText::subtreeChildWasAdded()
 {
     if (beingDestroyed() || !everHadLayout()) {
-        ASSERT(m_layoutAttributes.isEmpty());
+        ASSERT(m_descendantTextNodes.isEmpty());
         return;
     }
     if (documentBeingDestroyed())
         return;
 
     // The positioning elements cache depends on the size of each text layoutObject in the
     // subtree. If this changes, clear the cache. It will be rebuilt on the next layout.
     invalidatePositioningValues(LayoutInvalidationReason::ChildChanged);
     setNeedsTextMetricsUpdate();
 }
 
 void LayoutSVGText::subtreeChildWillBeRemoved()
 {
     if (beingDestroyed() || !everHadLayout()) {
-        ASSERT(m_layoutAttributes.isEmpty());
+        ASSERT(m_descendantTextNodes.isEmpty());
         return;
     }
 
     // The positioning elements cache depends on the size of each text layoutObject in the
     // subtree. If this changes, clear the cache. It will be rebuilt on the next layout.
     invalidatePositioningValues(LayoutInvalidationReason::ChildChanged);
     setNeedsTextMetricsUpdate();
 }
 
 void LayoutSVGText::subtreeTextDidChange()
 {
     ASSERT(!beingDestroyed());
     if (!everHadLayout()) {
-        ASSERT(m_layoutAttributes.isEmpty());
+        ASSERT(m_descendantTextNodes.isEmpty());
         return;
     }
 
     // The positioning elements cache depends on the size of each text object in
     // the subtree. If this changes, clear the cache and mark it for rebuilding
     // in the next layout.
     invalidatePositioningValues(LayoutInvalidationReason::TextChanged);
     setNeedsTextMetricsUpdate();
 }
 
 static inline void updateFontAndMetrics(LayoutSVGText& textRoot)
 {
     bool lastCharacterWasWhiteSpace = true;
     for (LayoutObject* descendant = textRoot.firstChild(); descendant; descendant = descendant->nextInPreOrder(&textRoot)) {
         if (!descendant->isSVGInlineText())
             continue;
         LayoutSVGInlineText& text = toLayoutSVGInlineText(*descendant);
         text.updateScaledFont();
         text.updateMetricsList(lastCharacterWasWhiteSpace);
     }
 }
 
-static inline void checkLayoutAttributesConsistency(LayoutSVGText* text, Vector<SVGTextLayoutAttributes*>& expectedLayoutAttributes)
+static inline void checkDescendantTextNodeConsistency(LayoutSVGText& text, Vector<LayoutSVGInlineText*>& expectedDescendantTextNodes)
 {
 #if ENABLE(ASSERT)
-    Vector<SVGTextLayoutAttributes*> newLayoutAttributes;
-    collectLayoutAttributes(text, newLayoutAttributes);
-    ASSERT(newLayoutAttributes == expectedLayoutAttributes);
+    Vector<LayoutSVGInlineText*> newDescendantTextNodes;
+    collectDescendantTextNodes(text, newDescendantTextNodes);
+    ASSERT(newDescendantTextNodes == expectedDescendantTextNodes);
 #endif
 }
 
 void LayoutSVGText::layout()
 {
     ASSERT(needsLayout());
     // This flag is set and reset as needed only within this function.
     ASSERT(!m_needsReordering);
     LayoutAnalyzer::Scope analyzer(*this);
 
@@ skipping 18 matching lines @@
     // update them before updating the layout attributes.
     if (m_needsTextMetricsUpdate || SVGLayoutSupport::findTreeRootObject(this)->isLayoutSizeChanged()) {
         updateFontAndMetrics(*this);
         m_needsTextMetricsUpdate = false;
         updateParentBoundaries = true;
     }
 
     // When the x/y/dx/dy/rotate lists change, we need to recompute the layout
     // attributes.
     if (m_needsPositioningValuesUpdate) {
-        m_layoutAttributes.clear();
-        collectLayoutAttributes(this, m_layoutAttributes);
+        m_descendantTextNodes.clear();
+        collectDescendantTextNodes(*this, m_descendantTextNodes);
 
         SVGTextLayoutAttributesBuilder(*this).buildLayoutAttributes();
 
         m_needsPositioningValuesUpdate = false;
         m_needsReordering = true;
         updateParentBoundaries = true;
     }
 
-    checkLayoutAttributesConsistency(this, m_layoutAttributes);
+    checkDescendantTextNodeConsistency(*this, m_descendantTextNodes);
 
     // Reduced version of LayoutBlock::layoutBlock(), which only takes care of SVG text.
     // All if branches that could cause early exit in LayoutBlocks layoutBlock() method are turned into assertions.
     ASSERT(!isInline());
     ASSERT(!simplifiedLayout());
     ASSERT(!scrollsOverflow());
     ASSERT(!hasControlClip());
     ASSERT(!positionedObjects());
     ASSERT(!isAnonymousBlock());
 
@@ skipping 173 matching lines @@
         paintInvalidationState.pushDelayedPaintInvalidationTarget(*this);
 
     if (reason == PaintInvalidationSVGResourceChange)
         newPaintInvalidationState.setForceSubtreeInvalidationWithinContainer();
 
     newPaintInvalidationState.updateForChildren();
     invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState);
 }
 
 } // namespace blink