Move transient/temporary RenderSVGResource state out of SVGInlineTextBox

Source/core/rendering/svg/SVGInlineTextBox.cpp

 /**
  * Copyright (C) 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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.
  *
@@ skipping 30 matching lines @@
 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
 #include "platform/FloatConversion.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 
 namespace blink {
 
 struct ExpectedSVGInlineTextBoxSize : public InlineTextBox {
     float float1;
     uint32_t bitfields : 1;
-    void* pointer;
     Vector<SVGTextFragment> vector;
 };
 
 COMPILE_ASSERT(sizeof(SVGInlineTextBox) == sizeof(ExpectedSVGInlineTextBoxSize), SVGInlineTextBox_is_not_of_expected_size);
 
 SVGInlineTextBox::SVGInlineTextBox(RenderObject& object)
     : InlineTextBox(object)
     , m_logicalHeight(0)
     , m_startsNewTextChunk(false)
-    , m_paintingResource(0)
 {
 }
 
 void SVGInlineTextBox::dirtyLineBoxes()
 {
     InlineTextBox::dirtyLineBoxes();
 
     // Clear the now stale text fragments
     clearTextFragments();
 
@@ skipping 142 matching lines @@
 
     int startPosition, endPosition;
     selectionStartEnd(startPosition, endPosition);
 
     int fragmentStartPosition = 0;
     int fragmentEndPosition = 0;
     AffineTransform fragmentTransform;
     unsigned textFragmentsSize = m_textFragments.size();
     for (unsigned i = 0; i < textFragmentsSize; ++i) {
         SVGTextFragment& fragment = m_textFragments.at(i);
-        ASSERT(!m_paintingResource);
 
         fragmentStartPosition = startPosition;
         fragmentEndPosition = endPosition;
         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
             continue;
 
         GraphicsContextStateSaver stateSaver(*paintInfo.context);
         fragment.buildFragmentTransform(fragmentTransform);
         if (!fragmentTransform.isIdentity())
             paintInfo.context->concatCTM(fragmentTransform);
 
         paintInfo.context->setFillColor(backgroundColor);
         paintInfo.context->fillRect(selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style), backgroundColor);
     }
-
-    ASSERT(!m_paintingResource);
 }
 
 void SVGInlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit, LayoutUnit)
 {
     ASSERT(paintInfo.shouldPaintWithinRoot(&renderer()));
     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
     ASSERT(truncation() == cNoTruncation);
 
     if (renderer().style()->visibility() != VISIBLE)
         return;
@@ skipping 39 matching lines @@
 
     if (textRenderer.frame() && textRenderer.frame()->view() && textRenderer.frame()->view()->paintBehavior() & PaintBehaviorRenderingSVGMask) {
         hasFill = true;
         hasVisibleStroke = false;
     }
 
     AffineTransform fragmentTransform;
     unsigned textFragmentsSize = m_textFragments.size();
     for (unsigned i = 0; i < textFragmentsSize; ++i) {
         SVGTextFragment& fragment = m_textFragments.at(i);
-        ASSERT(!m_paintingResource);
 
         GraphicsContextStateSaver stateSaver(*paintInfo.context, false);
         fragment.buildFragmentTransform(fragmentTransform);
         if (!fragmentTransform.isIdentity()) {
             stateSaver.save();
             paintInfo.context->concatCTM(fragmentTransform);
         }
 
         // 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.
         unsigned decorations = style->textDecorationsInEffect();
@@ skipping 28 matching lines @@
         }
 
         // Spec: Line-through should be drawn after the text is filled and stroked; thus, the line-through is rendered on top of the text.
         if (decorations & TextDecorationLineThrough)
             paintDecoration(paintInfo.context, TextDecorationLineThrough, fragment);
     }
 
     // finally, paint the outline if any
     if (style->hasOutline() && parentRenderer.isRenderInline())
         toRenderInline(parentRenderer).paintOutline(paintInfo, paintOffset);
-
-    ASSERT(!m_paintingResource);
 }
 
-bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, float scalingFactor,
-    RenderObject* renderer, RenderStyle* style, RenderSVGResourceModeFlags resourceMode)
+class PaintingResourceScope {
+public:
+    PaintingResourceScope(RenderObject& renderer, TextRun::RenderingContext* renderingContext = 0)

[f(malita), 2014/09/12 13:40:56]

We could try to go full RAII with this class: acquire the resource in the ctor,
release in the dtor, add an isAcquired() method for client tests and drop the
explicit acquire/release methods. Not sure of all the implications, maybe
something to look into later.

+        : m_renderer(renderer)
+        , m_renderingContext(renderingContext)
+        , m_paintingResource(0)
+    {
+    }
+    ~PaintingResourceScope() { ASSERT(!m_paintingResource); }
+
+    bool acquirePaintingResource(GraphicsContext*&, float scalingFactor, RenderStyle*, RenderSVGResourceModeFlags);
+    void releasePaintingResource(GraphicsContext*&, const Path*, RenderSVGResourceModeFlags);
+
+private:
+    RenderObject& m_renderer;
+    TextRun::RenderingContext* m_renderingContext;
+    RenderSVGResource* m_paintingResource;
+};
+
+bool PaintingResourceScope::acquirePaintingResource(GraphicsContext*& context, float scalingFactor,
+    RenderStyle* style, RenderSVGResourceModeFlags resourceMode)
 {
     // Callers must save the context state before calling when scalingFactor is not 1.
     ASSERT(scalingFactor);
-    ASSERT(renderer);
     ASSERT(style);
     ASSERT(resourceMode != ApplyToDefaultMode);
 
     bool hasFallback = false;
     if (resourceMode & ApplyToFillMode)
-        m_paintingResource = RenderSVGResource::fillPaintingResource(renderer, style, hasFallback);
+        m_paintingResource = RenderSVGResource::fillPaintingResource(&m_renderer, style, hasFallback);
     else if (resourceMode & ApplyToStrokeMode)
-        m_paintingResource = RenderSVGResource::strokePaintingResource(renderer, style, hasFallback);
+        m_paintingResource = RenderSVGResource::strokePaintingResource(&m_renderer, style, hasFallback);
     else {
         // We're either called for stroking or filling.
         ASSERT_NOT_REACHED();
     }
 
     if (!m_paintingResource)
         return false;
 
-    if (!m_paintingResource->applyResource(renderer, style, context, resourceMode)) {
+    if (!m_paintingResource->applyResource(&m_renderer, style, context, resourceMode)) {
         if (hasFallback) {
             m_paintingResource = RenderSVGResource::sharedSolidPaintingResource();
-            m_paintingResource->applyResource(renderer, style, context, resourceMode);
+            m_paintingResource->applyResource(&m_renderer, style, context, resourceMode);
         }
     }
 
     if (scalingFactor != 1 && resourceMode & ApplyToStrokeMode)
         context->setStrokeThickness(context->strokeThickness() * scalingFactor);
 
-    return true;
-}
-
-void SVGInlineTextBox::releasePaintingResource(GraphicsContext*& context, const Path* path,
-    RenderSVGResourceModeFlags resourceMode)
-{
-    ASSERT(m_paintingResource);
-
-    m_paintingResource->postApplyResource(&parent()->renderer(), context, resourceMode, path, 0);
-    m_paintingResource = 0;
-}
-
-bool SVGInlineTextBox::prepareGraphicsContextForTextPainting(GraphicsContext*& context,
-    float scalingFactor, TextRun& textRun, RenderStyle* style, RenderSVGResourceModeFlags resourceMode)
-{
-    bool acquiredResource = acquirePaintingResource(context, scalingFactor, &parent()->renderer(), style, resourceMode);
-    if (!acquiredResource)
-        return false;
-
 #if ENABLE(SVG_FONTS)
     // SVG Fonts need access to the painting resource used to draw the current text chunk.
-    TextRun::RenderingContext* renderingContext = textRun.renderingContext();
-    if (renderingContext)
-        static_cast<SVGTextRunRenderingContext*>(renderingContext)->setActivePaintingResource(m_paintingResource);
+    if (m_renderingContext)
+        static_cast<SVGTextRunRenderingContext*>(m_renderingContext)->setActivePaintingResource(m_paintingResource);
 #endif
 
     return true;
 }
 
-void SVGInlineTextBox::restoreGraphicsContextAfterTextPainting(GraphicsContext*& context,
-    TextRun& textRun, RenderSVGResourceModeFlags resourceMode)
+void PaintingResourceScope::releasePaintingResource(GraphicsContext*& context, const Path* path,
+    RenderSVGResourceModeFlags resourceMode)
 {
-    releasePaintingResource(context, 0, resourceMode);
+    ASSERT(m_paintingResource);
+
+    m_paintingResource->postApplyResource(&m_renderer, context, resourceMode, path, 0);
+    m_paintingResource = 0;
 
 #if ENABLE(SVG_FONTS)
-    TextRun::RenderingContext* renderingContext = textRun.renderingContext();
-    if (renderingContext)
-        static_cast<SVGTextRunRenderingContext*>(renderingContext)->setActivePaintingResource(0);
+    if (m_renderingContext)
+        static_cast<SVGTextRunRenderingContext*>(m_renderingContext)->setActivePaintingResource(0);
 #endif
 }
 
 TextRun SVGInlineTextBox::constructTextRun(RenderStyle* style, const SVGTextFragment& fragment) const
 {
     ASSERT(style);
 
     RenderText* text = &renderer();
 
     // FIXME(crbug.com/264211): This should not be necessary but can occur if we
@@ skipping 122 matching lines @@
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
 void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext* context, TextDecoration decoration,
     const SVGTextFragment& fragment, RenderObject* decorationRenderer, RenderSVGResourceModeFlags resourceMode)
 {
-    ASSERT(!m_paintingResource);
     ASSERT(resourceMode != ApplyToDefaultMode);
 
     RenderStyle* decorationStyle = decorationRenderer->style();
     ASSERT(decorationStyle);
 
     float scalingFactor = 1;
     Font scaledFont;
     RenderSVGInlineText::computeNewScaledFontForStyle(decorationRenderer, decorationStyle, scalingFactor, scaledFont);
     ASSERT(scalingFactor);
 
@@ skipping 15 matching lines @@
         context->scale(1 / scalingFactor, 1 / scalingFactor);
     }
 
     decorationOrigin.move(0, -scaledFontMetrics.floatAscent() + positionOffsetForDecoration(decoration, scaledFontMetrics, thickness));
 
     Path path;
     path.addRect(FloatRect(decorationOrigin, FloatSize(width, thickness)));
 
     // acquirePaintingResource also modifies state if the scalingFactor is non-identity.
     // Above we have saved the state for this case.
-    if (acquirePaintingResource(context, scalingFactor, decorationRenderer, decorationStyle, resourceMode))
-        releasePaintingResource(context, &path, resourceMode);
+    PaintingResourceScope resourceScope(*decorationRenderer);
+    if (resourceScope.acquirePaintingResource(context, scalingFactor, decorationStyle, resourceMode))
+        resourceScope.releasePaintingResource(context, &path, resourceMode);
 }
 
 void SVGInlineTextBox::paintTextWithShadows(GraphicsContext* context, RenderStyle* style,
     TextRun& textRun, const SVGTextFragment& fragment, int startPosition, int endPosition,
     RenderSVGResourceModeFlags resourceMode)
 {
     RenderSVGInlineText& textRenderer = toRenderSVGInlineText(this->renderer());
 
     float scalingFactor = textRenderer.scalingFactor();
     ASSERT(scalingFactor);
@@ skipping 10 matching lines @@
     if (scalingFactor != 1) {
         textOrigin.scale(scalingFactor, scalingFactor);
         textSize.scale(scalingFactor);
         context->save();
         context->scale(1 / scalingFactor, 1 / scalingFactor);
     }
 
     if (hasShadow)
         context->setDrawLooper(shadowList->createDrawLooper(DrawLooperBuilder::ShadowRespectsAlpha));
 
-    if (prepareGraphicsContextForTextPainting(context, scalingFactor, textRun, style, resourceMode)) {
+    PaintingResourceScope resourceScope(parent()->renderer(), textRun.renderingContext());
+    if (resourceScope.acquirePaintingResource(context, scalingFactor, style, resourceMode)) {
         TextRunPaintInfo textRunPaintInfo(textRun);
         textRunPaintInfo.from = startPosition;
         textRunPaintInfo.to = endPosition;
 
         float baseline = scaledFont.fontMetrics().floatAscent();
         textRunPaintInfo.bounds = FloatRect(textOrigin.x(), textOrigin.y() - baseline,
             textSize.width(), textSize.height());
 
         scaledFont.drawText(context, textRunPaintInfo, textOrigin);
-        restoreGraphicsContextAfterTextPainting(context, textRun, resourceMode);
+        resourceScope.releasePaintingResource(context, 0, resourceMode);
     }
 
     if (scalingFactor != 1)
         context->restore();
     else if (hasShadow)
         context->clearShadow();
 }
 
 void SVGInlineTextBox::paintText(GraphicsContext* context, RenderStyle* style,
     RenderStyle* selectionStyle, const SVGTextFragment& fragment,
@@ skipping 143 matching lines @@
                 renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
                 if (!result.addNodeToRectBasedTestResult(renderer().node(), request, locationInContainer, rect))
                     return true;
              }
         }
     }
     return false;
 }
 
 } // namespace blink