Refactor SVGTextLayoutEngine::currentLogicalCharacterMetrics

third_party/WebKit/Source/core/layout/svg/SVGTextLayoutEngine.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010-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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 258 matching lines @@
     m_visualMetricsIterator = SVGInlineTextMetricsIterator();
 
     // After all text fragments are stored in their correpsonding SVGInlineTextBoxes, we can layout individual text chunks.
     // Chunk layouting is only performed for line layout boxes, not for path layout, where it has already been done.
     SVGTextChunkBuilder chunkLayoutBuilder;
     chunkLayoutBuilder.processTextChunks(m_lineLayoutBoxes);
 
     m_lineLayoutBoxes.clear();
 }
 
-bool SVGTextLayoutEngine::currentLogicalCharacterAttributes(SVGTextLayoutAttributes*& logicalAttributes)
+const SVGTextLayoutAttributes* SVGTextLayoutEngine::nextLogicalAttributes()
 {
-    if (m_layoutAttributesPosition == m_layoutAttributes.size())
-        return false;
-
-    logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
-    ASSERT(logicalAttributes);
-
-    if (m_logicalCharacterOffset != logicalAttributes->context()->textLength())
-        return true;
-
+    ASSERT(m_layoutAttributesPosition < m_layoutAttributes.size());
     ++m_layoutAttributesPosition;
     if (m_layoutAttributesPosition == m_layoutAttributes.size())
-        return false;
+        return nullptr;
 
-    logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
     m_logicalMetricsListOffset = 0;
     m_logicalCharacterOffset = 0;
-    return true;
+    return m_layoutAttributes[m_layoutAttributesPosition];
 }
 
-bool SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextLayoutAttributes*& logicalAttributes, SVGTextMetrics& logicalMetrics)
+const SVGTextLayoutAttributes* SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextMetrics& logicalMetrics)
 {
+    // If we're consumed all layout attributes, there can be no more metrics.
+    if (m_layoutAttributesPosition == m_layoutAttributes.size())
+        return nullptr;
+
+    const SVGTextLayoutAttributes* logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
+    // If we reached the end of the text node associated with the current set
+    // of layout attributes, try to move to the next text node/set of layout
+    // attributes.
+    ASSERT(m_logicalCharacterOffset <= logicalAttributes->context()->textLength());
+    if (m_logicalCharacterOffset == logicalAttributes->context()->textLength()) {
+        logicalAttributes = nextLogicalAttributes();
+        if (!logicalAttributes)
+            return nullptr;
+    }
+
+    // We have set of layout attributes. Find the first non-collapsed text
+    // metrics cell.
     const Vector<SVGTextMetrics>* metricsList = &logicalAttributes->context()->metricsList();
     unsigned metricsListSize = metricsList->size();
     while (true) {
+        // If we run out of metrics, move to the next set of layout attributes.
         if (m_logicalMetricsListOffset == metricsListSize) {
-            if (!currentLogicalCharacterAttributes(logicalAttributes))
-                return false;
+            logicalAttributes = nextLogicalAttributes();
+            if (!logicalAttributes)
+                return nullptr;
 
             metricsList = &logicalAttributes->context()->metricsList();
             metricsListSize = metricsList->size();
             continue;
         }
 
         ASSERT(metricsListSize);
         ASSERT(m_logicalMetricsListOffset < metricsListSize);
         logicalMetrics = metricsList->at(m_logicalMetricsListOffset);
         if (logicalMetrics.isEmpty() || (!logicalMetrics.width() && !logicalMetrics.height())) {
             advanceToNextLogicalCharacter(logicalMetrics);
             continue;
         }
 
         // Stop if we found the next valid logical text metrics object.
-        return true;
+        return logicalAttributes;
     }
 
     ASSERT_NOT_REACHED();
-    return true;
+    return nullptr;
 }
 
 void SVGTextLayoutEngine::advanceToNextLogicalCharacter(const SVGTextMetrics& logicalMetrics)
 {
     ++m_logicalMetricsListOffset;
     m_logicalCharacterOffset += logicalMetrics.length();
 }
 
 void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, LineLayoutSVGInlineText textLineLayout, const ComputedStyle& style)
 {
@@ skipping 23 matching lines @@
 
     // Main layout algorithm.
     const unsigned boxEndOffset = textBox->start() + textBox->len();
     while (!m_visualMetricsIterator.isAtEnd() && m_visualMetricsIterator.characterOffset() < boxEndOffset) {
         const SVGTextMetrics& visualMetrics = m_visualMetricsIterator.metrics();
         if (visualMetrics.isEmpty()) {
             m_visualMetricsIterator.next();
             continue;
         }
 
-        SVGTextLayoutAttributes* logicalAttributes = nullptr;
-        if (!currentLogicalCharacterAttributes(logicalAttributes))
+        SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
+        const SVGTextLayoutAttributes* logicalAttributes = currentLogicalCharacterMetrics(logicalMetrics);
+        if (!logicalAttributes)
             break;
 
-        ASSERT(logicalAttributes);
-        SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
-        if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
-            break;
-
-        SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
+        const SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
         SVGCharacterData data;
-        SVGCharacterDataMap::iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
+        SVGCharacterDataMap::const_iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
         if (it != characterDataMap.end())
             data = it->value;
 
         // TODO(fs): Use the return value to eliminate the additional
         // hash-lookup below when determining if this text box should be tagged
         // as starting a new text chunk.
         setCurrentTextPosition(data);
 
         // When we've advanced to the box start offset, determine using the original x/y values,
         // whether this character starts a new text chunk, before doing any further processing.
@@ skipping 111 matching lines @@
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 } // namespace blink