Use precomputed text metrics instead of recomputing them in SVGTextQuery

third_party/WebKit/Source/core/layout/svg/SVGTextQuery.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 238 matching lines @@
     return false;
 }
 
 float SVGTextQuery::textLength() const
 {
     TextLengthData data;
     logicalQuery(m_queryRootLayoutObject, &data, textLengthCallback);
     return data.textLength;
 }
 
+const SVGTextMetrics& findMetricsForCharacter(const Vector<SVGTextMetrics>& textMetricsValues, const SVGTextFragment& fragment, unsigned startInFragment)
+{
+    // Find the text metrics cell that starts at or contains the character at |startInFragment|.
+    unsigned textMetricsOffset = fragment.metricsListOffset;
+    unsigned fragmentOffset = 0;
+    while (fragmentOffset < fragment.length) {
+        const SVGTextMetrics& metrics = textMetricsValues[textMetricsOffset++];
+        unsigned glyphEnd = fragmentOffset + metrics.length();
+        if (startInFragment < glyphEnd)
+            break;
+        fragmentOffset = glyphEnd;
+    }
+    return textMetricsValues[textMetricsOffset - 1];
+}
+
+static float calculateGlyphRange(const QueryData* queryData, const SVGTextFragment& fragment, unsigned start, unsigned end)
+{
+    float glyphRange = 0;
+    if (end <= start)

[fs, 2016/03/09 09:55:42]

Nit: I believe this should be uncommon enough here (this is usually dealt with
via mapStart...) to not warrant a special case, and just let it fall out
naturally in the loop below - i.e zero trips round the loop.

[pdr., 2016/03/09 19:13:50]

SGTM, done.

+        return glyphRange;
+
+    const Vector<SVGTextMetrics>& textMetricsValues = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
+    for (unsigned character = start; character < end; character++) {
+        SVGTextMetrics metrics = findMetricsForCharacter(textMetricsValues, fragment, character);

[fs, 2016/03/09 09:55:42]

Nit: const SVGTextMetrics&

[pdr., 2016/03/09 19:13:50]

Done.

+        glyphRange += queryData->isVerticalText ? metrics.height() : metrics.width();
+    }
+    return glyphRange;
+}
+
 // subStringLength() implementation
 struct SubStringLengthData : QueryData {
     SubStringLengthData(unsigned queryStartPosition, unsigned queryLength)
         : startPosition(queryStartPosition)
         , length(queryLength)
         , subStringLength(0)
     {
     }
 
     unsigned startPosition;
     unsigned length;
 
     float subStringLength;
 };
 
 static bool subStringLengthCallback(QueryData* queryData, const SVGTextFragment& fragment)
 {
     SubStringLengthData* data = static_cast<SubStringLengthData*>(queryData);
 
     int startPosition = data->startPosition;
     int endPosition = startPosition + data->length;
     if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
         return false;
 
-    SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textLineLayout, fragment.characterOffset + startPosition, endPosition - startPosition, queryData->textBox->direction());
-    data->subStringLength += queryData->isVerticalText ? metrics.height() : metrics.width();
+    data->subStringLength += calculateGlyphRange(queryData, fragment, startPosition, endPosition);
     return false;
 }
 
 float SVGTextQuery::subStringLength(unsigned startPosition, unsigned length) const
 {
     SubStringLengthData data(startPosition, length);
     logicalQuery(m_queryRootLayoutObject, &data, subStringLengthCallback);
     return data.subStringLength;
 }
 
 // startPositionOfCharacter() implementation
 struct StartPositionOfCharacterData : QueryData {
     StartPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }
 
     unsigned position;
     FloatPoint startPosition;
 };
 
 static FloatPoint calculateGlyphPositionWithoutTransform(const QueryData* queryData, const SVGTextFragment& fragment, int offsetInFragment)
 {
-    float glyphOffsetInDirection = 0;
-    if (offsetInFragment) {
-        SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textLineLayout, fragment.characterOffset, offsetInFragment, queryData->textBox->direction());
-        if (queryData->isVerticalText)
-            glyphOffsetInDirection = metrics.height();
-        else
-            glyphOffsetInDirection = metrics.width();
-    }
+    float glyphOffsetInDirection = calculateGlyphRange(queryData, fragment, 0, offsetInFragment);
 
     if (!queryData->textBox->isLeftToRightDirection()) {
         float fragmentExtent = queryData->isVerticalText ? fragment.height : fragment.width;
         glyphOffsetInDirection = fragmentExtent - glyphOffsetInDirection;
     }
 
     FloatPoint glyphPosition(fragment.x, fragment.y);
     if (queryData->isVerticalText)
         glyphPosition.move(0, glyphOffsetInDirection);
     else
@@ skipping 108 matching lines @@
 struct ExtentOfCharacterData : QueryData {
     ExtentOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }
 
     unsigned position;
     FloatRect extent;
 };
 
-const SVGTextMetrics& findMetricsForCharacter(const Vector<SVGTextMetrics>& textMetricsValues, const SVGTextFragment& fragment, unsigned startInFragment)
-{
-    // Find the text metrics cell that start at or contain the character at |startInFragment|.
-    unsigned textMetricsOffset = fragment.metricsListOffset;
-    unsigned fragmentOffset = 0;
-    while (fragmentOffset < fragment.length) {
-        const SVGTextMetrics& metrics = textMetricsValues[textMetricsOffset++];
-        unsigned glyphEnd = fragmentOffset + metrics.length();
-        if (startInFragment < glyphEnd)
-            break;
-        fragmentOffset = glyphEnd;
-    }
-    return textMetricsValues[textMetricsOffset - 1];
-}
-
 static inline void calculateGlyphBoundaries(const QueryData* queryData, const SVGTextFragment& fragment, int startPosition, FloatRect& extent)
 {
     float scalingFactor = queryData->textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
 
     FloatPoint glyphPosition = calculateGlyphPositionWithoutTransform(queryData, fragment, startPosition);
     glyphPosition.move(0, -queryData->textLineLayout.scaledFont().fontMetrics().floatAscent() / scalingFactor);
     extent.setLocation(glyphPosition);
 
     // Use the SVGTextMetrics computed by SVGTextMetricsBuilder (which spends
@@ skipping 133 matching lines @@
 }
 
 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
 {
     CharacterNumberAtPositionData data(position);
     spatialQuery(m_queryRootLayoutObject, &data, characterNumberAtPositionCallback);
     return data.characterNumberWithin(m_queryRootLayoutObject);
 }
 
 } // namespace blink