Make calculateGlyphBoundaries helper return the computed bounds

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 441 matching lines @@
 struct ExtentOfCharacterData : QueryData {
     ExtentOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }
 
     unsigned position;
     FloatRect extent;
 };
 
-static inline void calculateGlyphBoundaries(const QueryData* queryData, const SVGTextFragment& fragment, int startPosition, FloatRect& extent)
+static inline FloatRect calculateGlyphBoundaries(const QueryData* queryData, const SVGTextFragment& fragment, int startPosition)
 {
     float scalingFactor = queryData->textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
 
     FloatPoint glyphPosition = calculateGlyphPositionWithoutTransform(queryData, fragment, startPosition);
     glyphPosition.move(0, -queryData->textLineLayout.scaledFont().getFontMetrics().floatAscent() / scalingFactor);
-    extent.setLocation(glyphPosition);
 
     // 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);
 
     // 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));
-    extent.setSize(glyphSize);
 
     // If RTL, adjust the starting point to align with the LHS of the glyph bounding box.
     if (!queryData->textBox->isLeftToRightDirection()) {
         if (queryData->isVerticalText)
-            extent.move(0, -glyphSize.height());
+            glyphPosition.move(0, -glyphSize.height());
         else
-            extent.move(-glyphSize.width(), 0);
+            glyphPosition.move(-glyphSize.width(), 0);
     }
 
+    FloatRect extent(glyphPosition, glyphSize);
     if (fragment.isTransformed()) {
         AffineTransform fragmentTransform = fragment.buildFragmentTransform(SVGTextFragment::TransformIgnoringTextLength);
         extent = fragmentTransform.mapRect(extent);
     }
+    return extent;
 }
 
 static inline FloatRect calculateFragmentBoundaries(LineLayoutSVGInlineText textLineLayout, const SVGTextFragment& fragment)
 {
     float scalingFactor = textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
     float baseline = textLineLayout.scaledFont().getFontMetrics().floatAscent() / scalingFactor;
     return fragment.boundingBox(baseline);
 }
 
 static bool extentOfCharacterCallback(QueryData* queryData, const SVGTextFragment& fragment)
 {
     ExtentOfCharacterData* data = static_cast<ExtentOfCharacterData*>(queryData);
 
     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
         return false;
 
-    calculateGlyphBoundaries(queryData, fragment, startPosition, data->extent);
+    data->extent = calculateGlyphBoundaries(queryData, fragment, startPosition);
     return true;
 }
 
 FloatRect SVGTextQuery::extentOfCharacter(unsigned position) const
 {
     ExtentOfCharacterData data(position);
     logicalQuery(m_queryRootLayoutObject, &data, extentOfCharacterCallback);
     return data.extent;
 }
 
@@ skipping 54 matching lines @@
 {
     CharacterNumberAtPositionData* data = static_cast<CharacterNumberAtPositionData*>(queryData);
 
     // Test the query point against the bounds of the entire fragment first.
     FloatRect fragmentExtents = calculateFragmentBoundaries(queryData->textLineLayout, fragment);
     if (!fragmentExtents.contains(data->position))
         return false;
 
     // Iterate through the glyphs in this fragment, and check if their extents
     // contain the query point.
-    FloatRect extent;
     const Vector<SVGTextMetrics>& textMetrics = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
     unsigned textMetricsOffset = fragment.metricsListOffset;
     unsigned fragmentOffset = 0;
     while (fragmentOffset < fragment.length) {
-        calculateGlyphBoundaries(queryData, fragment, fragmentOffset, extent);
+        FloatRect extent = calculateGlyphBoundaries(queryData, fragment, fragmentOffset);
         if (extent.contains(data->position)) {
             // Compute the character offset of the glyph within the text node.
             unsigned offsetInBox = fragment.characterOffset - queryData->textBox->start() + fragmentOffset;
             data->offsetInTextNode = logicalOffsetInTextNode(queryData->textLineLayout, queryData->textBox, offsetInBox);
             data->hitLayoutItem = LineLayoutItem(data->textLineLayout);
             return true;
         }
         fragmentOffset += textMetrics[textMetricsOffset].length();
         textMetricsOffset++;
     }
     return false;
 }
 
 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
 {
     CharacterNumberAtPositionData data(position);
     spatialQuery(m_queryRootLayoutObject, &data, characterNumberAtPositionCallback);
     return data.characterNumberWithin(m_queryRootLayoutObject);
 }
 
 } // namespace blink