Make the findMetricsForCharacter SVGTextQuery-helper return an iterator

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 150 matching lines @@
         collectTextBoxesInLogicalOrder(textLineLayout, textBoxes);
 
         for (const SVGInlineTextBox* textBox : textBoxes) {
             if (queryTextBox(queryData, textBox, fragmentCallback))
                 return;
             queryData->currentOffset += textBox->len();
         }
     }
 }
 
-static void modifyStartEndPositionsRespectingLigatures(const QueryData* queryData, const SVGTextFragment& fragment, int& startPosition, int& endPosition)
-{
-    const Vector<SVGTextMetrics>& textMetricsValues = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
-
-    unsigned textMetricsOffset = fragment.metricsListOffset;
-    int fragmentOffset = 0;
-    int fragmentEnd = static_cast<int>(fragment.length);
-
-    // Find the text metrics cell that start at or contain the character startPosition.
-    while (fragmentOffset < fragmentEnd) {
-        const SVGTextMetrics& metrics = textMetricsValues[textMetricsOffset];
-        int glyphEnd = fragmentOffset + metrics.length();
-        if (startPosition < glyphEnd)
-            break;
-        fragmentOffset = glyphEnd;
-        textMetricsOffset++;
-    }
-
-    startPosition = fragmentOffset;
-
-    // Find the text metrics cell that contain or ends at the character endPosition.
-    while (fragmentOffset < fragmentEnd) {
-        const SVGTextMetrics& metrics = textMetricsValues[textMetricsOffset];
-        fragmentOffset += metrics.length();
-        if (fragmentOffset >= endPosition)
-            break;
-        textMetricsOffset++;
-    }
-
-    endPosition = fragmentOffset;
-}
-
 static bool mapStartEndPositionsIntoFragmentCoordinates(const QueryData* queryData, const SVGTextFragment& fragment, int& startPosition, int& endPosition)
 {
     unsigned boxStart = queryData->currentOffset;
 
     // Make <startPosition, endPosition> offsets relative to the current text box.
     startPosition -= boxStart;
     endPosition -= boxStart;
 
     // Reuse the same logic used for text selection & painting, to map our
     // query start/length into start/endPositions of the current text fragment.
-    if (!queryData->textBox->mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition))
-        return false;
-
-    modifyStartEndPositionsRespectingLigatures(queryData, fragment, startPosition, endPosition);
-    ASSERT(startPosition < endPosition);
-    return true;
+    return queryData->textBox->mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition);
 }
 
 // numberOfCharacters() implementation
 static bool numberOfCharactersCallback(QueryData*, const SVGTextFragment&)
 {
     // no-op
     return false;
 }
 
 unsigned SVGTextQuery::numberOfCharacters() const
@@ skipping 20 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)
+using MetricsList = Vector<SVGTextMetrics>;
+
+MetricsList::const_iterator findMetricsForCharacter(const MetricsList& metricsList, const SVGTextFragment& fragment, unsigned startInFragment)
 {
     // Find the text metrics cell that starts at or contains the character at |startInFragment|.
-    unsigned textMetricsOffset = fragment.metricsListOffset;
+    MetricsList::const_iterator metrics = metricsList.begin() + fragment.metricsListOffset;
     unsigned fragmentOffset = 0;
     while (fragmentOffset < fragment.length) {
-        const SVGTextMetrics& metrics = textMetricsValues[textMetricsOffset++];
-        unsigned glyphEnd = fragmentOffset + metrics.length();
-        if (startInFragment < glyphEnd)
+        fragmentOffset += metrics->length();
+        if (startInFragment < fragmentOffset)
             break;
-        fragmentOffset = glyphEnd;
+        ++metrics;
     }
-    return textMetricsValues[textMetricsOffset - 1];
+    ASSERT(metrics <= metricsList.end());
+    return metrics;
 }
 
 static float calculateGlyphRange(const QueryData* queryData, const SVGTextFragment& fragment, unsigned start, unsigned end)
 {
+    const MetricsList& metricsList = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
+    auto metrics = findMetricsForCharacter(metricsList, fragment, start);
+    auto endMetrics = findMetricsForCharacter(metricsList, fragment, end);
     float glyphRange = 0;
-    const Vector<SVGTextMetrics>& textMetricsValues = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
-    for (unsigned character = start; character < end; character++) {
-        const SVGTextMetrics& metrics = findMetricsForCharacter(textMetricsValues, fragment, character);
-        glyphRange += queryData->isVerticalText ? metrics.height() : metrics.width();
-    }
+    for (; metrics != endMetrics; ++metrics)
+        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)
     {
@@ skipping 29 matching lines @@
 struct StartPositionOfCharacterData : QueryData {
     StartPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }
 
     unsigned position;
     FloatPoint startPosition;
 };
 
-static FloatPoint calculateGlyphPositionWithoutTransform(const QueryData* queryData, const SVGTextFragment& fragment, int offsetInFragment)
+static FloatPoint calculateGlyphPositionWithoutTransform(const QueryData* queryData, const SVGTextFragment& fragment, unsigned offsetInFragment)
 {
     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
         glyphPosition.move(glyphOffsetInDirection, 0);
 
     return glyphPosition;
 }
 
-static FloatPoint calculateGlyphPosition(const QueryData* queryData, const SVGTextFragment& fragment, int offsetInFragment)
+static FloatPoint calculateGlyphPosition(const QueryData* queryData, const SVGTextFragment& fragment, unsigned offsetInFragment)
 {
     FloatPoint glyphPosition = calculateGlyphPositionWithoutTransform(queryData, fragment, offsetInFragment);
     if (fragment.isTransformed()) {
         AffineTransform fragmentTransform = fragment.buildFragmentTransform(SVGTextFragment::TransformIgnoringTextLength);
         glyphPosition = fragmentTransform.mapPoint(glyphPosition);
     }
     return glyphPosition;
 }
 
 static bool startPositionOfCharacterCallback(QueryData* queryData, const SVGTextFragment& fragment)
@@ skipping 29 matching lines @@
 
 static bool endPositionOfCharacterCallback(QueryData* queryData, const SVGTextFragment& fragment)
 {
     EndPositionOfCharacterData* data = static_cast<EndPositionOfCharacterData*>(queryData);
 
     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
         return false;
 
-    // TODO(fs): mapStartEndPositionsIntoFragmentCoordinates(...) above applies
-    // some heuristics for ligatures, so why not just use endPosition here?
-    // (rather than startPosition+1)
-    data->endPosition = calculateGlyphPosition(queryData, fragment, startPosition + 1);
+    data->endPosition = calculateGlyphPosition(queryData, fragment, endPosition);
     return true;
 }
 
 FloatPoint SVGTextQuery::endPositionOfCharacter(unsigned position) const
 {
     EndPositionOfCharacterData data(position);
     logicalQuery(m_queryRootLayoutObject, &data, endPositionOfCharacterCallback);
     return data.endPosition;
 }
 
@@ skipping 50 matching lines @@
 {
     float scalingFactor = queryData->textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
 
     FloatPoint glyphPosition = calculateGlyphPositionWithoutTransform(queryData, fragment, startPosition);
     glyphPosition.move(0, -queryData->textLineLayout.scaledFont().getFontMetrics().floatAscent() / scalingFactor);
 
     // Use the SVGTextMetrics computed by SVGTextMetricsBuilder (which spends
     // time attempting to compute more correct glyph bounds already, handling
     // cursive scripts to some degree.)
-    const Vector<SVGTextMetrics>& textMetricsValues = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
-    const SVGTextMetrics& metrics = findMetricsForCharacter(textMetricsValues, fragment, startPosition);
+    const MetricsList& textMetricsValues = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
+    auto metrics = findMetricsForCharacter(textMetricsValues, fragment, startPosition);
 
     // TODO(fs): Negative glyph extents seems kind of weird to have, but
     // presently it can occur in some cases (like Arabic.)
-    FloatSize glyphSize(std::max<float>(metrics.width(), 0), std::max<float>(metrics.height(), 0));
+    FloatSize glyphSize(std::max<float>(metrics->width(), 0), std::max<float>(metrics->height(), 0));
 
     // If RTL, adjust the starting point to align with the LHS of the glyph bounding box.
     if (!queryData->textBox->isLeftToRightDirection()) {
         if (queryData->isVerticalText)
             glyphPosition.move(0, -glyphSize.height());
         else
             glyphPosition.move(-glyphSize.width(), 0);
     }
 
     FloatRect extent(glyphPosition, glyphSize);
@@ skipping 115 matching lines @@
 }
 
 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
 {
     CharacterNumberAtPositionData data(position);
     spatialQuery(m_queryRootLayoutObject, &data, characterNumberAtPositionCallback);
     return data.characterNumberWithin(m_queryRootLayoutObject);
 }
 
 } // namespace blink