Home | History | Annotate | Download | only in svg 
      1 /**
      2  * Copyright (C) 2007 Rob Buis <buis (at) kde.org>
      3  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann (at) kde.org>
      4  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
      5  *
      6  * This library is free software; you can redistribute it and/or
      7  * modify it under the terms of the GNU Library General Public
      8  * License as published by the Free Software Foundation; either
      9  * version 2 of the License, or (at your option) any later version.
     10  *
     11  * This library is distributed in the hope that it will be useful,
     12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14  * Library General Public License for more details.
     15  *
     16  * You should have received a copy of the GNU Library General Public License
     17  * along with this library; see the file COPYING.LIB.  If not, write to
     18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     19  * Boston, MA 02110-1301, USA.
     20  */
     21 
     22 #include "config.h"
     23 #include "core/rendering/svg/SVGInlineTextBox.h"
     24 
     25 #include "core/page/Frame.h"
     26 #include "core/page/FrameView.h"
     27 #include "core/platform/FloatConversion.h"
     28 #include "core/platform/graphics/DrawLooper.h"
     29 #include "core/platform/graphics/FontCache.h"
     30 #include "core/platform/graphics/GraphicsContextStateSaver.h"
     31 #include "core/rendering/HitTestResult.h"
     32 #include "core/rendering/InlineFlowBox.h"
     33 #include "core/rendering/PointerEventsHitRules.h"
     34 #include "core/rendering/svg/RenderSVGInlineText.h"
     35 #include "core/rendering/svg/RenderSVGResource.h"
     36 #include "core/rendering/svg/RenderSVGResourceSolidColor.h"
     37 #include "core/rendering/svg/SVGResourcesCache.h"
     38 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
     39 
     40 using namespace std;
     41 
     42 namespace WebCore {
     43 
     44 struct ExpectedSVGInlineTextBoxSize : public InlineTextBox {
     45     float float1;
     46     uint32_t bitfields : 5;
     47     void* pointer;
     48     Vector<SVGTextFragment> vector;
     49 };
     50 
     51 COMPILE_ASSERT(sizeof(SVGInlineTextBox) == sizeof(ExpectedSVGInlineTextBoxSize), SVGInlineTextBox_is_not_of_expected_size);
     52 
     53 SVGInlineTextBox::SVGInlineTextBox(RenderObject* object)
     54     : InlineTextBox(object)
     55     , m_logicalHeight(0)
     56     , m_paintingResourceMode(ApplyToDefaultMode)
     57     , m_startsNewTextChunk(false)
     58     , m_paintingResource(0)
     59 {
     60 }
     61 
     62 void SVGInlineTextBox::dirtyLineBoxes()
     63 {
     64     InlineTextBox::dirtyLineBoxes();
     65 
     66     // Clear the now stale text fragments
     67     clearTextFragments();
     68 
     69     // And clear any following text fragments as the text on which they
     70     // depend may now no longer exist, or glyph positions may be wrong
     71     InlineTextBox* nextBox = nextTextBox();
     72     if (nextBox)
     73         nextBox->dirtyLineBoxes();
     74 }
     75 
     76 int SVGInlineTextBox::offsetForPosition(float, bool) const
     77 {
     78     // SVG doesn't use the standard offset <-> position selection system, as it's not suitable for SVGs complex needs.
     79     // vertical text selection, inline boxes spanning multiple lines (contrary to HTML, etc.)
     80     ASSERT_NOT_REACHED();
     81     return 0;
     82 }
     83 
     84 int SVGInlineTextBox::offsetForPositionInFragment(const SVGTextFragment& fragment, float position, bool includePartialGlyphs) const
     85 {
     86     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
     87     ASSERT(textRenderer);
     88 
     89     float scalingFactor = textRenderer->scalingFactor();
     90     ASSERT(scalingFactor);
     91 
     92     RenderStyle* style = textRenderer->style();
     93     ASSERT(style);
     94 
     95     TextRun textRun = constructTextRun(style, fragment);
     96 
     97     // Eventually handle lengthAdjust="spacingAndGlyphs".
     98     // FIXME: Handle vertical text.
     99     AffineTransform fragmentTransform;
    100     fragment.buildFragmentTransform(fragmentTransform);
    101     if (!fragmentTransform.isIdentity())
    102         textRun.setHorizontalGlyphStretch(narrowPrecisionToFloat(fragmentTransform.xScale()));
    103 
    104     return fragment.characterOffset - start() + textRenderer->scaledFont().offsetForPosition(textRun, position * scalingFactor, includePartialGlyphs);
    105 }
    106 
    107 float SVGInlineTextBox::positionForOffset(int) const
    108 {
    109     // SVG doesn't use the offset <-> position selection system.
    110     ASSERT_NOT_REACHED();
    111     return 0;
    112 }
    113 
    114 FloatRect SVGInlineTextBox::selectionRectForTextFragment(const SVGTextFragment& fragment, int startPosition, int endPosition, RenderStyle* style)
    115 {
    116     ASSERT(startPosition < endPosition);
    117     ASSERT(style);
    118 
    119     FontCachePurgePreventer fontCachePurgePreventer;
    120 
    121     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
    122     ASSERT(textRenderer);
    123 
    124     float scalingFactor = textRenderer->scalingFactor();
    125     ASSERT(scalingFactor);
    126 
    127     const Font& scaledFont = textRenderer->scaledFont();
    128     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
    129     FloatPoint textOrigin(fragment.x, fragment.y);
    130     if (scalingFactor != 1)
    131         textOrigin.scale(scalingFactor, scalingFactor);
    132 
    133     textOrigin.move(0, -scaledFontMetrics.floatAscent());
    134 
    135     FloatRect selectionRect = scaledFont.selectionRectForText(constructTextRun(style, fragment), textOrigin, fragment.height * scalingFactor, startPosition, endPosition);
    136     if (scalingFactor == 1)
    137         return selectionRect;
    138 
    139     selectionRect.scale(1 / scalingFactor);
    140     return selectionRect;
    141 }
    142 
    143 LayoutRect SVGInlineTextBox::localSelectionRect(int startPosition, int endPosition)
    144 {
    145     int boxStart = start();
    146     startPosition = max(startPosition - boxStart, 0);
    147     endPosition = min(endPosition - boxStart, static_cast<int>(len()));
    148     if (startPosition >= endPosition)
    149         return LayoutRect();
    150 
    151     RenderText* text = textRenderer();
    152     ASSERT(text);
    153 
    154     RenderStyle* style = text->style();
    155     ASSERT(style);
    156 
    157     AffineTransform fragmentTransform;
    158     FloatRect selectionRect;
    159     int fragmentStartPosition = 0;
    160     int fragmentEndPosition = 0;
    161 
    162     unsigned textFragmentsSize = m_textFragments.size();
    163     for (unsigned i = 0; i < textFragmentsSize; ++i) {
    164         const SVGTextFragment& fragment = m_textFragments.at(i);
    165 
    166         fragmentStartPosition = startPosition;
    167         fragmentEndPosition = endPosition;
    168         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
    169             continue;
    170 
    171         FloatRect fragmentRect = selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style);
    172         fragment.buildFragmentTransform(fragmentTransform);
    173         if (!fragmentTransform.isIdentity())
    174             fragmentRect = fragmentTransform.mapRect(fragmentRect);
    175 
    176         selectionRect.unite(fragmentRect);
    177     }
    178 
    179     return enclosingIntRect(selectionRect);
    180 }
    181 
    182 static inline bool textShouldBePainted(RenderSVGInlineText* textRenderer)
    183 {
    184     // Font::pixelSize(), returns FontDescription::computedPixelSize(), which returns "int(x + 0.5)".
    185     // If the absolute font size on screen is below x=0.5, don't render anything.
    186     return textRenderer->scaledFont().pixelSize();
    187 }
    188 
    189 void SVGInlineTextBox::paintSelectionBackground(PaintInfo& paintInfo)
    190 {
    191     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
    192     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
    193     ASSERT(truncation() == cNoTruncation);
    194 
    195     if (renderer()->style()->visibility() != VISIBLE)
    196         return;
    197 
    198     RenderObject* parentRenderer = parent()->renderer();
    199     ASSERT(parentRenderer);
    200     ASSERT(!parentRenderer->document()->printing());
    201 
    202     // Determine whether or not we're selected.
    203     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
    204     bool hasSelection = selectionState() != RenderObject::SelectionNone;
    205     if (!hasSelection || paintSelectedTextOnly)
    206         return;
    207 
    208     Color backgroundColor = renderer()->selectionBackgroundColor();
    209     if (!backgroundColor.alpha())
    210         return;
    211 
    212     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
    213     ASSERT(textRenderer);
    214     if (!textShouldBePainted(textRenderer))
    215         return;
    216 
    217     RenderStyle* style = parentRenderer->style();
    218     ASSERT(style);
    219 
    220     RenderStyle* selectionStyle = style;
    221     if (hasSelection) {
    222         selectionStyle = parentRenderer->getCachedPseudoStyle(SELECTION);
    223         if (!selectionStyle)
    224             selectionStyle = style;
    225     }
    226 
    227     int startPosition, endPosition;
    228     selectionStartEnd(startPosition, endPosition);
    229 
    230     int fragmentStartPosition = 0;
    231     int fragmentEndPosition = 0;
    232     AffineTransform fragmentTransform;
    233     unsigned textFragmentsSize = m_textFragments.size();
    234     for (unsigned i = 0; i < textFragmentsSize; ++i) {
    235         SVGTextFragment& fragment = m_textFragments.at(i);
    236         ASSERT(!m_paintingResource);
    237 
    238         fragmentStartPosition = startPosition;
    239         fragmentEndPosition = endPosition;
    240         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
    241             continue;
    242 
    243         GraphicsContextStateSaver stateSaver(*paintInfo.context);
    244         fragment.buildFragmentTransform(fragmentTransform);
    245         if (!fragmentTransform.isIdentity())
    246             paintInfo.context->concatCTM(fragmentTransform);
    247 
    248         paintInfo.context->setFillColor(backgroundColor);
    249         paintInfo.context->fillRect(selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style), backgroundColor);
    250 
    251         m_paintingResourceMode = ApplyToDefaultMode;
    252     }
    253 
    254     ASSERT(!m_paintingResource);
    255 }
    256 
    257 void SVGInlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint&, LayoutUnit, LayoutUnit)
    258 {
    259     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
    260     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
    261     ASSERT(truncation() == cNoTruncation);
    262 
    263     if (renderer()->style()->visibility() != VISIBLE)
    264         return;
    265 
    266     // Note: We're explicitely not supporting composition & custom underlines and custom highlighters - unlike InlineTextBox.
    267     // If we ever need that for SVG, it's very easy to refactor and reuse the code.
    268 
    269     RenderObject* parentRenderer = parent()->renderer();
    270     ASSERT(parentRenderer);
    271 
    272     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
    273     bool hasSelection = !parentRenderer->document()->printing() && selectionState() != RenderObject::SelectionNone;
    274     if (!hasSelection && paintSelectedTextOnly)
    275         return;
    276 
    277     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
    278     ASSERT(textRenderer);
    279     if (!textShouldBePainted(textRenderer))
    280         return;
    281 
    282     RenderStyle* style = parentRenderer->style();
    283     ASSERT(style);
    284 
    285     const SVGRenderStyle* svgStyle = style->svgStyle();
    286     ASSERT(svgStyle);
    287 
    288     bool hasFill = svgStyle->hasFill();
    289     bool hasVisibleStroke = svgStyle->hasVisibleStroke();
    290 
    291     RenderStyle* selectionStyle = style;
    292     if (hasSelection) {
    293         selectionStyle = parentRenderer->getCachedPseudoStyle(SELECTION);
    294         if (selectionStyle) {
    295             const SVGRenderStyle* svgSelectionStyle = selectionStyle->svgStyle();
    296             ASSERT(svgSelectionStyle);
    297 
    298             if (!hasFill)
    299                 hasFill = svgSelectionStyle->hasFill();
    300             if (!hasVisibleStroke)
    301                 hasVisibleStroke = svgSelectionStyle->hasVisibleStroke();
    302         } else
    303             selectionStyle = style;
    304     }
    305 
    306     if (textRenderer->frame() && textRenderer->frame()->view() && textRenderer->frame()->view()->paintBehavior() & PaintBehaviorRenderingSVGMask) {
    307         hasFill = true;
    308         hasVisibleStroke = false;
    309     }
    310 
    311     AffineTransform fragmentTransform;
    312     unsigned textFragmentsSize = m_textFragments.size();
    313     for (unsigned i = 0; i < textFragmentsSize; ++i) {
    314         SVGTextFragment& fragment = m_textFragments.at(i);
    315         ASSERT(!m_paintingResource);
    316 
    317         GraphicsContextStateSaver stateSaver(*paintInfo.context);
    318         fragment.buildFragmentTransform(fragmentTransform);
    319         if (!fragmentTransform.isIdentity())
    320             paintInfo.context->concatCTM(fragmentTransform);
    321 
    322         // Spec: All text decorations except line-through should be drawn before the text is filled and stroked; thus, the text is rendered on top of these decorations.
    323         int decorations = style->textDecorationsInEffect();
    324         if (decorations & TextDecorationUnderline)
    325             paintDecoration(paintInfo.context, TextDecorationUnderline, fragment);
    326         if (decorations & TextDecorationOverline)
    327             paintDecoration(paintInfo.context, TextDecorationOverline, fragment);
    328 
    329         // Fill text
    330         if (hasFill) {
    331             m_paintingResourceMode = ApplyToFillMode | ApplyToTextMode;
    332             paintText(paintInfo.context, style, selectionStyle, fragment, hasSelection, paintSelectedTextOnly);
    333         }
    334 
    335         // Stroke text
    336         if (hasVisibleStroke) {
    337             m_paintingResourceMode = ApplyToStrokeMode | ApplyToTextMode;
    338             paintText(paintInfo.context, style, selectionStyle, fragment, hasSelection, paintSelectedTextOnly);
    339         }
    340 
    341         // Spec: Line-through should be drawn after the text is filled and stroked; thus, the line-through is rendered on top of the text.
    342         if (decorations & TextDecorationLineThrough)
    343             paintDecoration(paintInfo.context, TextDecorationLineThrough, fragment);
    344 
    345         m_paintingResourceMode = ApplyToDefaultMode;
    346     }
    347 
    348     ASSERT(!m_paintingResource);
    349 }
    350 
    351 bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, float scalingFactor, RenderObject* renderer, RenderStyle* style)
    352 {
    353     ASSERT(scalingFactor);
    354     ASSERT(renderer);
    355     ASSERT(style);
    356     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
    357 
    358     StyleColor fallbackColor;
    359     if (m_paintingResourceMode & ApplyToFillMode)
    360         m_paintingResource = RenderSVGResource::fillPaintingResource(renderer, style, fallbackColor);
    361     else if (m_paintingResourceMode & ApplyToStrokeMode)
    362         m_paintingResource = RenderSVGResource::strokePaintingResource(renderer, style, fallbackColor);
    363     else {
    364         // We're either called for stroking or filling.
    365         ASSERT_NOT_REACHED();
    366     }
    367 
    368     if (!m_paintingResource)
    369         return false;
    370 
    371     if (!m_paintingResource->applyResource(renderer, style, context, m_paintingResourceMode)) {
    372         if (fallbackColor.isValid()) {
    373             RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();
    374             fallbackResource->setColor(fallbackColor.color());
    375 
    376             m_paintingResource = fallbackResource;
    377             m_paintingResource->applyResource(renderer, style, context, m_paintingResourceMode);
    378         }
    379     }
    380 
    381     if (scalingFactor != 1 && m_paintingResourceMode & ApplyToStrokeMode)
    382         context->setStrokeThickness(context->strokeThickness() * scalingFactor);
    383 
    384     return true;
    385 }
    386 
    387 void SVGInlineTextBox::releasePaintingResource(GraphicsContext*& context, const Path* path)
    388 {
    389     ASSERT(m_paintingResource);
    390 
    391     RenderObject* parentRenderer = parent()->renderer();
    392     ASSERT(parentRenderer);
    393 
    394     m_paintingResource->postApplyResource(parentRenderer, context, m_paintingResourceMode, path, /*RenderSVGShape*/ 0);
    395     m_paintingResource = 0;
    396 }
    397 
    398 bool SVGInlineTextBox::prepareGraphicsContextForTextPainting(GraphicsContext*& context, float scalingFactor, TextRun& textRun, RenderStyle* style)
    399 {
    400     bool acquiredResource = acquirePaintingResource(context, scalingFactor, parent()->renderer(), style);
    401     if (!acquiredResource)
    402         return false;
    403 
    404 #if ENABLE(SVG_FONTS)
    405     // SVG Fonts need access to the painting resource used to draw the current text chunk.
    406     TextRun::RenderingContext* renderingContext = textRun.renderingContext();
    407     if (renderingContext)
    408         static_cast<SVGTextRunRenderingContext*>(renderingContext)->setActivePaintingResource(m_paintingResource);
    409 #endif
    410 
    411     return true;
    412 }
    413 
    414 void SVGInlineTextBox::restoreGraphicsContextAfterTextPainting(GraphicsContext*& context, TextRun& textRun)
    415 {
    416     releasePaintingResource(context, /* path */0);
    417 
    418 #if ENABLE(SVG_FONTS)
    419     TextRun::RenderingContext* renderingContext = textRun.renderingContext();
    420     if (renderingContext)
    421         static_cast<SVGTextRunRenderingContext*>(renderingContext)->setActivePaintingResource(0);
    422 #else
    423     UNUSED_PARAM(textRun);
    424 #endif
    425 }
    426 
    427 TextRun SVGInlineTextBox::constructTextRun(RenderStyle* style, const SVGTextFragment& fragment) const
    428 {
    429     ASSERT(style);
    430     ASSERT(textRenderer());
    431 
    432     RenderText* text = textRenderer();
    433     ASSERT(text);
    434 
    435     // FIXME(crbug.com/264211): This should not be necessary but can occur if we
    436     //                          layout during layout. Remove this when 264211 is fixed.
    437     RELEASE_ASSERT(!text->needsLayout());
    438 
    439     TextRun run(static_cast<const LChar*>(0) // characters, will be set below if non-zero.
    440                 , 0 // length, will be set below if non-zero.
    441                 , 0 // xPos, only relevant with allowTabs=true
    442                 , 0 // padding, only relevant for justified text, not relevant for SVG
    443                 , TextRun::AllowTrailingExpansion
    444                 , direction()
    445                 , dirOverride() || style->rtlOrdering() == VisualOrder /* directionalOverride */);
    446 
    447     if (fragment.length) {
    448         if (text->is8Bit())
    449             run.setText(text->characters8() + fragment.characterOffset, fragment.length);
    450         else
    451             run.setText(text->characters16() + fragment.characterOffset, fragment.length);
    452     }
    453 
    454     if (textRunNeedsRenderingContext(style->font()))
    455         run.setRenderingContext(SVGTextRunRenderingContext::create(text));
    456 
    457     run.disableRoundingHacks();
    458 
    459     // We handle letter & word spacing ourselves.
    460     run.disableSpacing();
    461 
    462     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
    463     run.setCharactersLength(text->textLength() - fragment.characterOffset);
    464     ASSERT(run.charactersLength() >= run.length());
    465     return run;
    466 }
    467 
    468 bool SVGInlineTextBox::mapStartEndPositionsIntoFragmentCoordinates(const SVGTextFragment& fragment, int& startPosition, int& endPosition) const
    469 {
    470     if (startPosition >= endPosition)
    471         return false;
    472 
    473     int offset = static_cast<int>(fragment.characterOffset) - start();
    474     int length = static_cast<int>(fragment.length);
    475 
    476     if (startPosition >= offset + length || endPosition <= offset)
    477         return false;
    478 
    479     if (startPosition < offset)
    480         startPosition = 0;
    481     else
    482         startPosition -= offset;
    483 
    484     if (endPosition > offset + length)
    485         endPosition = length;
    486     else {
    487         ASSERT(endPosition >= offset);
    488         endPosition -= offset;
    489     }
    490 
    491     ASSERT(startPosition < endPosition);
    492     return true;
    493 }
    494 
    495 static inline float positionOffsetForDecoration(TextDecoration decoration, const FontMetrics& fontMetrics, float thickness)
    496 {
    497     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
    498     // Compatible with Batik/Opera.
    499     if (decoration == TextDecorationUnderline)
    500         return fontMetrics.floatAscent() + thickness * 1.5f;
    501     if (decoration == TextDecorationOverline)
    502         return thickness;
    503     if (decoration == TextDecorationLineThrough)
    504         return fontMetrics.floatAscent() * 5 / 8.0f;
    505 
    506     ASSERT_NOT_REACHED();
    507     return 0.0f;
    508 }
    509 
    510 static inline float thicknessForDecoration(TextDecoration, const Font& font)
    511 {
    512     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
    513     // Compatible with Batik/Opera
    514     return font.size() / 20.0f;
    515 }
    516 
    517 static inline RenderObject* findRenderObjectDefininingTextDecoration(InlineFlowBox* parentBox)
    518 {
    519     // Lookup first render object in parent hierarchy which has text-decoration set.
    520     RenderObject* renderer = 0;
    521     while (parentBox) {
    522         renderer = parentBox->renderer();
    523 
    524         if (renderer->style() && renderer->style()->textDecoration() != TextDecorationNone)
    525             break;
    526 
    527         parentBox = parentBox->parent();
    528     }
    529 
    530     ASSERT(renderer);
    531     return renderer;
    532 }
    533 
    534 void SVGInlineTextBox::paintDecoration(GraphicsContext* context, TextDecoration decoration, const SVGTextFragment& fragment)
    535 {
    536     if (textRenderer()->style()->textDecorationsInEffect() == TextDecorationNone)
    537         return;
    538 
    539     // Find out which render style defined the text-decoration, as its fill/stroke properties have to be used for drawing instead of ours.
    540     RenderObject* decorationRenderer = findRenderObjectDefininingTextDecoration(parent());
    541     RenderStyle* decorationStyle = decorationRenderer->style();
    542     ASSERT(decorationStyle);
    543 
    544     if (decorationStyle->visibility() == HIDDEN)
    545         return;
    546 
    547     const SVGRenderStyle* svgDecorationStyle = decorationStyle->svgStyle();
    548     ASSERT(svgDecorationStyle);
    549 
    550     bool hasDecorationFill = svgDecorationStyle->hasFill();
    551     bool hasVisibleDecorationStroke = svgDecorationStyle->hasVisibleStroke();
    552 
    553     if (hasDecorationFill) {
    554         m_paintingResourceMode = ApplyToFillMode;
    555         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
    556     }
    557 
    558     if (hasVisibleDecorationStroke) {
    559         m_paintingResourceMode = ApplyToStrokeMode;
    560         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
    561     }
    562 }
    563 
    564 void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext* context, TextDecoration decoration, const SVGTextFragment& fragment, RenderObject* decorationRenderer)
    565 {
    566     ASSERT(!m_paintingResource);
    567     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
    568 
    569     RenderStyle* decorationStyle = decorationRenderer->style();
    570     ASSERT(decorationStyle);
    571 
    572     float scalingFactor = 1;
    573     Font scaledFont;
    574     RenderSVGInlineText::computeNewScaledFontForStyle(decorationRenderer, decorationStyle, scalingFactor, scaledFont);
    575     ASSERT(scalingFactor);
    576 
    577     // The initial y value refers to overline position.
    578     float thickness = thicknessForDecoration(decoration, scaledFont);
    579 
    580     if (fragment.width <= 0 && thickness <= 0)
    581         return;
    582 
    583     FloatPoint decorationOrigin(fragment.x, fragment.y);
    584     float width = fragment.width;
    585     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
    586 
    587     GraphicsContextStateSaver stateSaver(*context);
    588     if (scalingFactor != 1) {
    589         width *= scalingFactor;
    590         decorationOrigin.scale(scalingFactor, scalingFactor);
    591         context->scale(FloatSize(1 / scalingFactor, 1 / scalingFactor));
    592     }
    593 
    594     decorationOrigin.move(0, -scaledFontMetrics.floatAscent() + positionOffsetForDecoration(decoration, scaledFontMetrics, thickness));
    595 
    596     Path path;
    597     path.addRect(FloatRect(decorationOrigin, FloatSize(width, thickness)));
    598 
    599     if (acquirePaintingResource(context, scalingFactor, decorationRenderer, decorationStyle))
    600         releasePaintingResource(context, &path);
    601 }
    602 
    603 void SVGInlineTextBox::paintTextWithShadows(GraphicsContext* context, RenderStyle* style, TextRun& textRun, const SVGTextFragment& fragment, int startPosition, int endPosition)
    604 {
    605     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
    606     ASSERT(textRenderer);
    607 
    608     float scalingFactor = textRenderer->scalingFactor();
    609     ASSERT(scalingFactor);
    610 
    611     const Font& scaledFont = textRenderer->scaledFont();
    612     const ShadowData* shadow = style->textShadow();
    613 
    614     // Text shadows are disabled when printing. http://crbug.com/258321
    615     bool hasShadow = shadow && !context->printing();
    616 
    617     FloatPoint textOrigin(fragment.x, fragment.y);
    618     FloatSize textSize(fragment.width, fragment.height);
    619 
    620     if (scalingFactor != 1) {
    621         textOrigin.scale(scalingFactor, scalingFactor);
    622         textSize.scale(scalingFactor);
    623         context->save();
    624         context->scale(FloatSize(1 / scalingFactor, 1 / scalingFactor));
    625     }
    626 
    627     if (hasShadow) {
    628         DrawLooper drawLooper;
    629         do {
    630             FloatSize offset(shadow->x(), shadow->y());
    631             drawLooper.addShadow(offset, shadow->blur(), textRenderer->resolveColor(shadow->color(), Color::stdShadowColor),
    632                 DrawLooper::ShadowRespectsTransforms, DrawLooper::ShadowRespectsAlpha);
    633         } while ((shadow = shadow->next()));
    634         drawLooper.addUnmodifiedContent();
    635         context->setDrawLooper(drawLooper);
    636     }
    637 
    638     if (prepareGraphicsContextForTextPainting(context, scalingFactor, textRun, style)) {
    639         TextRunPaintInfo textRunPaintInfo(textRun);
    640         textRunPaintInfo.from = startPosition;
    641         textRunPaintInfo.to = endPosition;
    642         textRunPaintInfo.bounds = FloatRect(textOrigin, textSize);
    643         scaledFont.drawText(context, textRunPaintInfo, textOrigin);
    644         restoreGraphicsContextAfterTextPainting(context, textRun);
    645     }
    646 
    647     if (scalingFactor != 1)
    648         context->restore();
    649     else if (hasShadow)
    650         context->clearShadow();
    651 }
    652 
    653 void SVGInlineTextBox::paintText(GraphicsContext* context, RenderStyle* style, RenderStyle* selectionStyle, const SVGTextFragment& fragment, bool hasSelection, bool paintSelectedTextOnly)
    654 {
    655     ASSERT(style);
    656     ASSERT(selectionStyle);
    657 
    658     int startPosition = 0;
    659     int endPosition = 0;
    660     if (hasSelection) {
    661         selectionStartEnd(startPosition, endPosition);
    662         hasSelection = mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition);
    663     }
    664 
    665     // Fast path if there is no selection, just draw the whole chunk part using the regular style
    666     TextRun textRun = constructTextRun(style, fragment);
    667     if (!hasSelection || startPosition >= endPosition) {
    668         paintTextWithShadows(context, style, textRun, fragment, 0, fragment.length);
    669         return;
    670     }
    671 
    672     // Eventually draw text using regular style until the start position of the selection
    673     if (startPosition > 0 && !paintSelectedTextOnly)
    674         paintTextWithShadows(context, style, textRun, fragment, 0, startPosition);
    675 
    676     // Draw text using selection style from the start to the end position of the selection
    677     if (style != selectionStyle)
    678         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, selectionStyle);
    679 
    680     TextRun selectionTextRun = constructTextRun(selectionStyle, fragment);
    681     paintTextWithShadows(context, selectionStyle, textRun, fragment, startPosition, endPosition);
    682 
    683     if (style != selectionStyle)
    684         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, style);
    685 
    686     // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part
    687     if (endPosition < static_cast<int>(fragment.length) && !paintSelectedTextOnly)
    688         paintTextWithShadows(context, style, textRun, fragment, endPosition, fragment.length);
    689 }
    690 
    691 FloatRect SVGInlineTextBox::calculateBoundaries() const
    692 {
    693     FloatRect textRect;
    694 
    695     RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
    696     ASSERT(textRenderer);
    697 
    698     float scalingFactor = textRenderer->scalingFactor();
    699     ASSERT(scalingFactor);
    700 
    701     float baseline = textRenderer->scaledFont().fontMetrics().floatAscent() / scalingFactor;
    702 
    703     AffineTransform fragmentTransform;
    704     unsigned textFragmentsSize = m_textFragments.size();
    705     for (unsigned i = 0; i < textFragmentsSize; ++i) {
    706         const SVGTextFragment& fragment = m_textFragments.at(i);
    707         FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
    708         fragment.buildFragmentTransform(fragmentTransform);
    709         if (!fragmentTransform.isIdentity())
    710             fragmentRect = fragmentTransform.mapRect(fragmentRect);
    711 
    712         textRect.unite(fragmentRect);
    713     }
    714 
    715     return textRect;
    716 }
    717 
    718 bool SVGInlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit, LayoutUnit)
    719 {
    720     // FIXME: integrate with InlineTextBox::nodeAtPoint better.
    721     ASSERT(!isLineBreak());
    722 
    723     PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, renderer()->style()->pointerEvents());
    724     bool isVisible = renderer()->style()->visibility() == VISIBLE;
    725     if (isVisible || !hitRules.requireVisible) {
    726         if ((hitRules.canHitStroke && (renderer()->style()->svgStyle()->hasStroke() || !hitRules.requireStroke))
    727             || (hitRules.canHitFill && (renderer()->style()->svgStyle()->hasFill() || !hitRules.requireFill))) {
    728             FloatPoint boxOrigin(x(), y());
    729             boxOrigin.moveBy(accumulatedOffset);
    730             FloatRect rect(boxOrigin, size());
    731             if (locationInContainer.intersects(rect)) {
    732                 renderer()->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
    733                 if (!result.addNodeToRectBasedTestResult(renderer()->node(), request, locationInContainer, rect))
    734                     return true;
    735              }
    736         }
    737     }
    738     return false;
    739 }
    740 
    741 } // namespace WebCore
    742