Drop early-outs for "no boxes" in SVGTextQuery entrypoints

Source/core/rendering/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 101 matching lines @@
             continue;
         }
 
         if (child->isSVGInlineTextBox())
             m_textBoxes.append(toSVGInlineTextBox(child));
     }
 }
 
 bool SVGTextQuery::executeQuery(Data* queryData, ProcessTextFragmentCallback fragmentCallback) const
 {
-    ASSERT(!m_textBoxes.isEmpty());
-
     unsigned processedCharacters = 0;
     unsigned textBoxCount = m_textBoxes.size();
 
     // Loop over all text boxes
     for (unsigned textBoxPosition = 0; textBoxPosition < textBoxCount; ++textBoxPosition) {
         queryData->textBox = m_textBoxes.at(textBoxPosition);
         queryData->textRenderer = &toRenderSVGInlineText(queryData->textBox->textRenderer());
         ASSERT(queryData->textRenderer->style());
         ASSERT(queryData->textRenderer->style()->svgStyle());
 
@@ skipping 119 matching lines @@
 
 // numberOfCharacters() implementation
 bool SVGTextQuery::numberOfCharactersCallback(Data*, const SVGTextFragment&) const
 {
     // no-op
     return false;
 }
 
 unsigned SVGTextQuery::numberOfCharacters() const
 {
-    if (m_textBoxes.isEmpty())
-        return 0;
-
     Data data;
     executeQuery(&data, &SVGTextQuery::numberOfCharactersCallback);
     return data.processedCharacters;
 }
 
 // textLength() implementation
 struct TextLengthData : SVGTextQuery::Data {
     TextLengthData()
         : textLength(0)
     {
     }
 
     float textLength;
 };
 
 bool SVGTextQuery::textLengthCallback(Data* queryData, const SVGTextFragment& fragment) const
 {
     TextLengthData* data = static_cast<TextLengthData*>(queryData);
     data->textLength += queryData->isVerticalText ? fragment.height : fragment.width;
     return false;
 }
 
 float SVGTextQuery::textLength() const
 {
-    if (m_textBoxes.isEmpty())
-        return 0;
-
     TextLengthData data;
     executeQuery(&data, &SVGTextQuery::textLengthCallback);
     return data.textLength;
 }
 
 // subStringLength() implementation
 struct SubStringLengthData : SVGTextQuery::Data {
     SubStringLengthData(unsigned queryStartPosition, unsigned queryLength)
         : startPosition(queryStartPosition)
         , length(queryLength)
@@ skipping 16 matching lines @@
     if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
         return false;
 
     SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textRenderer, fragment.characterOffset + startPosition, endPosition - startPosition);
     data->subStringLength += queryData->isVerticalText ? metrics.height() : metrics.width();
     return false;
 }
 
 float SVGTextQuery::subStringLength(unsigned startPosition, unsigned length) const
 {
-    if (m_textBoxes.isEmpty())
-        return 0;
-
     SubStringLengthData data(startPosition, length);
     executeQuery(&data, &SVGTextQuery::subStringLengthCallback);
     return data.subStringLength;
 }
 
 // startPositionOfCharacter() implementation
 struct StartPositionOfCharacterData : SVGTextQuery::Data {
     StartPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
@@ skipping 26 matching lines @@
     fragment.buildFragmentTransform(fragmentTransform, SVGTextFragment::TransformIgnoringTextLength);
     if (fragmentTransform.isIdentity())
         return true;
 
     data->startPosition = fragmentTransform.mapPoint(data->startPosition);
     return true;
 }
 
 FloatPoint SVGTextQuery::startPositionOfCharacter(unsigned position) const
 {
-    if (m_textBoxes.isEmpty())
-        return FloatPoint();
-
     StartPositionOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::startPositionOfCharacterCallback);
     return data.startPosition;
 }
 
 // endPositionOfCharacter() implementation
 struct EndPositionOfCharacterData : SVGTextQuery::Data {
     EndPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
@@ skipping 24 matching lines @@
     fragment.buildFragmentTransform(fragmentTransform, SVGTextFragment::TransformIgnoringTextLength);
     if (fragmentTransform.isIdentity())
         return true;
 
     data->endPosition = fragmentTransform.mapPoint(data->endPosition);
     return true;
 }
 
 FloatPoint SVGTextQuery::endPositionOfCharacter(unsigned position) const
 {
-    if (m_textBoxes.isEmpty())
-        return FloatPoint();
-
     EndPositionOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::endPositionOfCharacterCallback);
     return data.endPosition;
 }
 
 // rotationOfCharacter() implementation
 struct RotationOfCharacterData : SVGTextQuery::Data {
     RotationOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
         , rotation(0)
@@ skipping 20 matching lines @@
     else {
         fragmentTransform.scale(1 / fragmentTransform.xScale(), 1 / fragmentTransform.yScale());
         data->rotation = narrowPrecisionToFloat(rad2deg(atan2(fragmentTransform.b(), fragmentTransform.a())));
     }
 
     return true;
 }
 
 float SVGTextQuery::rotationOfCharacter(unsigned position) const
 {
-    if (m_textBoxes.isEmpty())
-        return 0;
-
     RotationOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::rotationOfCharacterCallback);
     return data.rotation;
 }
 
 // extentOfCharacter() implementation
 struct ExtentOfCharacterData : SVGTextQuery::Data {
     ExtentOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
@@ skipping 35 matching lines @@
     int endPosition = startPosition + 1;
     if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
         return false;
 
     calculateGlyphBoundaries(queryData, fragment, startPosition, data->extent);
     return true;
 }
 
 FloatRect SVGTextQuery::extentOfCharacter(unsigned position) const
 {
-    if (m_textBoxes.isEmpty())
-        return FloatRect();
-
     ExtentOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::extentOfCharacterCallback);
     return data.extent;
 }
 
 // characterNumberAtPosition() implementation
 struct CharacterNumberAtPositionData : SVGTextQuery::Data {
     CharacterNumberAtPositionData(const FloatPoint& queryPosition)
         : position(queryPosition)
     {
@@ skipping 22 matching lines @@
             return true;
         }
         fragmentOffset += textMetrics[textMetricsOffset].length();
         textMetricsOffset++;
     }
     return false;
 }
 
 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
 {
-    if (m_textBoxes.isEmpty())
-        return -1;
-
     CharacterNumberAtPositionData data(position);
     if (!executeQuery(&data, &SVGTextQuery::characterNumberAtPositionCallback))
         return -1;
 
     return data.processedCharacters;
 }
 
 }