[Line Layout API] Convert QueryData and descendants to line layout API

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 21 matching lines @@
 #include "wtf/MathExtras.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 // Base structure for callback user data
 struct QueryData {
     QueryData()
         : isVerticalText(false)
         , currentOffset(0)
-        , textLayoutObject(nullptr)
+        , textLineLayout(nullptr)
         , textBox(nullptr)
     {
     }
 
     bool isVerticalText;
     unsigned currentOffset;
-    LayoutSVGInlineText* textLayoutObject;
+    LineLayoutSVGInlineText textLineLayout;
     const SVGInlineTextBox* textBox;
 };
 
 static inline InlineFlowBox* flowBoxForLayoutObject(LayoutObject* layoutObject)
 {
     if (!layoutObject)
         return nullptr;
 
     if (layoutObject->isLayoutBlock()) {
         // If we're given a block element, it has to be a LayoutSVGText.
@@ skipping 38 matching lines @@
         if (child->isSVGInlineTextBox())
             textBoxes.append(toSVGInlineTextBox(child));
     }
 }
 
 typedef bool ProcessTextFragmentCallback(QueryData*, const SVGTextFragment&);
 
 static bool queryTextBox(QueryData* queryData, const SVGInlineTextBox* textBox, ProcessTextFragmentCallback fragmentCallback)
 {
     queryData->textBox = textBox;
-    queryData->textLayoutObject = &toLayoutSVGInlineText(textBox->layoutObject());
+    queryData->textLineLayout = LineLayoutSVGInlineText(&toLayoutSVGInlineText(textBox->layoutObject()));
 
     queryData->isVerticalText = !textBox->layoutObject().style()->isHorizontalWritingMode();
 
     // Loop over all text fragments in this text box, firing a callback for each.
     for (const SVGTextFragment& fragment : textBox->textFragments()) {
         if (fragmentCallback(queryData, fragment))
             return true;
     }
     return false;
 }
 
 // Execute a query in "spatial" order starting at |queryRoot|. This means
 // walking the lines boxes in the order they would get painted.
 static void spatialQuery(LayoutObject* queryRoot, QueryData* queryData, ProcessTextFragmentCallback fragmentCallback)
 {
     Vector<SVGInlineTextBox*> textBoxes;
     collectTextBoxesInFlowBox(flowBoxForLayoutObject(queryRoot), textBoxes);
 
     // Loop over all text boxes
     for (const SVGInlineTextBox* textBox : textBoxes) {
         if (queryTextBox(queryData, textBox, fragmentCallback))
             return;
     }
 }
 
-static void collectTextBoxesInLogicalOrder(const LayoutSVGInlineText& textLayoutObject, Vector<SVGInlineTextBox*>& textBoxes)
+static void collectTextBoxesInLogicalOrder(LineLayoutSVGInlineText textLineLayout, Vector<SVGInlineTextBox*>& textBoxes)
 {
     textBoxes.shrink(0);
-    for (InlineTextBox* textBox = textLayoutObject.firstTextBox(); textBox; textBox = textBox->nextTextBox())
+    for (InlineTextBox* textBox = textLineLayout.firstTextBox(); textBox; textBox = textBox->nextTextBox())
         textBoxes.append(toSVGInlineTextBox(textBox));
     std::sort(textBoxes.begin(), textBoxes.end(), InlineTextBox::compareByStart);
 }
 
 // Execute a query in "logical" order starting at |queryRoot|. This means
 // walking the lines boxes for each layout object in layout tree (pre)order.
 static void logicalQuery(LayoutObject* queryRoot, QueryData* queryData, ProcessTextFragmentCallback fragmentCallback)
 {
     if (!queryRoot)
         return;
 
     // Walk the layout tree in pre-order, starting at the specified root, and
     // run the query for each text node.
     Vector<SVGInlineTextBox*> textBoxes;
     for (LayoutObject* layoutObject = queryRoot->slowFirstChild(); layoutObject; layoutObject = layoutObject->nextInPreOrder(queryRoot)) {
         if (!layoutObject->isSVGInlineText())
             continue;
 
-        LayoutSVGInlineText& textLayoutObject = toLayoutSVGInlineText(*layoutObject);
-        ASSERT(textLayoutObject.style());
+        LineLayoutSVGInlineText textLineLayout = LineLayoutSVGInlineText(toLayoutSVGInlineText(layoutObject));
+        ASSERT(textLineLayout.style());
 
         // TODO(fs): Allow filtering the search earlier, since we should be
         // able to trivially reject (prune) at least some of the queries.
-        collectTextBoxesInLogicalOrder(textLayoutObject, textBoxes);
+        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->textLayoutObject->layoutAttributes()->textMetricsValues();
+    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)
@@ skipping 89 matching lines @@
 
 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(LineLayoutSVGInlineText(queryData->textLayoutObject), fragment.characterOffset + startPosition, endPosition - startPosition, queryData->textBox->direction());
+    SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textLineLayout, fragment.characterOffset + startPosition, endPosition - startPosition, queryData->textBox->direction());
     data->subStringLength += queryData->isVerticalText ? metrics.height() : metrics.width();
     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(LineLayoutSVGInlineText(queryData->textLayoutObject), fragment.characterOffset, offsetInFragment, queryData->textBox->direction());
+        SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textLineLayout, fragment.characterOffset, offsetInFragment, queryData->textBox->direction());
         if (queryData->isVerticalText)
             glyphOffsetInDirection = metrics.height();
         else
             glyphOffsetInDirection = metrics.width();
     }
 
     if (!queryData->textBox->isLeftToRightDirection()) {
         float fragmentExtent = queryData->isVerticalText ? fragment.height : fragment.width;
         glyphOffsetInDirection = fragmentExtent - glyphOffsetInDirection;
     }
@@ skipping 133 matching lines @@
         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->textLayoutObject->scalingFactor();
+    float scalingFactor = queryData->textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
 
     FloatPoint glyphPosition = calculateGlyphPositionWithoutTransform(queryData, fragment, startPosition);
-    glyphPosition.move(0, -queryData->textLayoutObject->scaledFont().fontMetrics().floatAscent() / scalingFactor);
+    glyphPosition.move(0, -queryData->textLineLayout.scaledFont().fontMetrics().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->textLayoutObject->layoutAttributes()->textMetricsValues();
+    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());
         else
             extent.move(-glyphSize.width(), 0);
     }
 
     AffineTransform fragmentTransform;
     fragment.buildFragmentTransform(fragmentTransform, SVGTextFragment::TransformIgnoringTextLength);
 
     extent = fragmentTransform.mapRect(extent);
 }
 
-static inline FloatRect calculateFragmentBoundaries(const LayoutSVGInlineText& textLayoutObject, const SVGTextFragment& fragment)
+static inline FloatRect calculateFragmentBoundaries(LineLayoutSVGInlineText textLineLayout, const SVGTextFragment& fragment)
 {
-    float scalingFactor = textLayoutObject.scalingFactor();
+    float scalingFactor = textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
-    float baseline = textLayoutObject.scaledFont().fontMetrics().floatAscent() / scalingFactor;
+    float baseline = textLineLayout.scaledFont().fontMetrics().floatAscent() / scalingFactor;
 
     AffineTransform fragmentTransform;
     FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
     fragment.buildFragmentTransform(fragmentTransform);
     return fragmentTransform.mapRect(fragmentRect);
 }
 
 static bool extentOfCharacterCallback(QueryData* queryData, const SVGTextFragment& fragment)
 {
     ExtentOfCharacterData* data = static_cast<ExtentOfCharacterData*>(queryData);
@@ skipping 11 matching lines @@
 {
     ExtentOfCharacterData data(position);
     logicalQuery(m_queryRootLayoutObject, &data, extentOfCharacterCallback);
     return data.extent;
 }
 
 // characterNumberAtPosition() implementation
 struct CharacterNumberAtPositionData : QueryData {
     CharacterNumberAtPositionData(const FloatPoint& queryPosition)
         : position(queryPosition)
-        , hitLayoutObject(nullptr)
+        , hitLayoutItem(nullptr)
         , offsetInTextNode(0)
     {
     }
 
     int characterNumberWithin(const LayoutObject* queryRoot) const;
 
     FloatPoint position;
-    LayoutObject* hitLayoutObject;
+    LineLayoutItem hitLayoutItem;
     int offsetInTextNode;
 };
 
 int CharacterNumberAtPositionData::characterNumberWithin(const LayoutObject* queryRoot) const
 {
     // http://www.w3.org/TR/SVG/single-page.html#text-__svg__SVGTextContentElement__getCharNumAtPosition
     // "If no such character exists, a value of -1 is returned."
-    if (!hitLayoutObject)
+    if (!hitLayoutItem)
         return -1;
     ASSERT(queryRoot);
     int characterNumber = offsetInTextNode;
 
     // Accumulate the lengths of all the text nodes preceding the target layout
     // object within the queried root, to get the complete character number.
-    for (const LayoutObject* layoutObject = hitLayoutObject->previousInPreOrder(queryRoot);
-        layoutObject; layoutObject = layoutObject->previousInPreOrder(queryRoot)) {
-        if (!layoutObject->isSVGInlineText())
+    for (LineLayoutItem layoutItem = hitLayoutItem.previousInPreOrder(queryRoot);
+        layoutItem; layoutItem = layoutItem.previousInPreOrder(queryRoot)) {
+        if (!layoutItem.isSVGInlineText())
             continue;
-        characterNumber += toLayoutSVGInlineText(layoutObject)->resolvedTextLength();
+        characterNumber += LineLayoutSVGInlineText(layoutItem).resolvedTextLength();
     }
     return characterNumber;
 }
 
-static unsigned logicalOffsetInTextNode(const LayoutSVGInlineText& textLayoutObject, const SVGInlineTextBox* startTextBox, unsigned fragmentOffset)
+static unsigned logicalOffsetInTextNode(LineLayoutSVGInlineText textLineLayout, const SVGInlineTextBox* startTextBox, unsigned fragmentOffset)
 {
     Vector<SVGInlineTextBox*> textBoxes;
-    collectTextBoxesInLogicalOrder(textLayoutObject, textBoxes);
+    collectTextBoxesInLogicalOrder(textLineLayout, textBoxes);
 
     ASSERT(startTextBox);
     size_t index = textBoxes.find(startTextBox);
     ASSERT(index != kNotFound);
 
     unsigned offset = fragmentOffset;
     while (index) {
         --index;
         offset += textBoxes[index]->len();
     }
     return offset;
 }
 
 static bool characterNumberAtPositionCallback(QueryData* queryData, const SVGTextFragment& fragment)
 {
     CharacterNumberAtPositionData* data = static_cast<CharacterNumberAtPositionData*>(queryData);
 
     // Test the query point against the bounds of the entire fragment first.
-    FloatRect fragmentExtents = calculateFragmentBoundaries(*queryData->textLayoutObject, fragment);
+    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->textLayoutObject->layoutAttributes()->textMetricsValues();
+    const Vector<SVGTextMetrics>& textMetrics = queryData->textLineLayout.layoutAttributes()->textMetricsValues();
     unsigned textMetricsOffset = fragment.metricsListOffset;
     unsigned fragmentOffset = 0;
     while (fragmentOffset < fragment.length) {
         calculateGlyphBoundaries(queryData, fragment, fragmentOffset, extent);
         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->textLayoutObject, queryData->textBox, offsetInBox);
-            data->hitLayoutObject = data->textLayoutObject;
+            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);
 }
 
 }