Implement interfaces in PaintInfo and make it a class.

Source/core/rendering/svg/SVGRenderingContext.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-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
@@ skipping 40 matching lines @@
 SVGRenderingContext::~SVGRenderingContext()
 {
     // Fast path if we don't need to restore anything.
     if (!(m_renderingFlags & ActionsNeeded))
         return;
 
     ASSERT(m_object && m_paintInfo);
 
     if (m_renderingFlags & EndFilterLayer) {
         ASSERT(m_filter);
-        m_filter->postApplyResource(m_object, m_paintInfo->context, ApplyToDefaultMode, 0, 0);
-        m_paintInfo->context = m_savedContext;
-        m_paintInfo->rect = m_savedPaintRect;
+        GraphicsContext* context = m_paintInfo->getContext();

[do-not-use, 2013/08/05 11:16:30]

Useless new local variable?

+        m_filter->postApplyResource(m_object, context, ApplyToDefaultMode, 0, 0);
+        m_paintInfo->setContext(m_savedContext);
+        m_paintInfo->setRect(m_savedPaintRect);
     }
 
     if (m_renderingFlags & EndOpacityLayer)
-        m_paintInfo->context->endTransparencyLayer();
+        m_paintInfo->getContext()->endTransparencyLayer();
 
     if (m_renderingFlags & RestoreGraphicsContext)
-        m_paintInfo->context->restore();
+        m_paintInfo->getContext()->restore();
 }
 
 void SVGRenderingContext::prepareToRenderSVGContent(RenderObject* object, PaintInfo& paintInfo, NeedsGraphicsContextSave needsGraphicsContextSave)
 {
     ASSERT(object);
 
 #ifndef NDEBUG
     // This function must not be called twice!
     ASSERT(!(m_renderingFlags & PrepareToRenderSVGContentWasCalled));
     m_renderingFlags |= PrepareToRenderSVGContentWasCalled;
 #endif
 
     m_object = object;
     m_paintInfo = &paintInfo;
     m_filter = 0;
 
     // We need to save / restore the context even if the initialization failed.
     if (needsGraphicsContextSave == SaveGraphicsContext) {
-        m_paintInfo->context->save();
+        m_paintInfo->getContext()->save();
         m_renderingFlags |= RestoreGraphicsContext;
     }
 
     RenderStyle* style = m_object->style();
     ASSERT(style);
 
     const SVGRenderStyle* svgStyle = style->svgStyle();
     ASSERT(svgStyle);
 
     // Setup transparency layers before setting up SVG resources!
     bool isRenderingMask = isRenderingMaskImage(m_object);
     float opacity = isRenderingMask ? 1 : style->opacity();
     BlendMode blendMode = isRenderingMask ? BlendModeNormal : style->blendMode();
     if (opacity < 1 || blendMode != BlendModeNormal) {
         FloatRect repaintRect = m_object->repaintRectInLocalCoordinates();
 
         if (opacity < 1 || blendMode != BlendModeNormal) {
-            m_paintInfo->context->clip(repaintRect);
+            m_paintInfo->getContext()->clip(repaintRect);
             if (blendMode != BlendModeNormal) {
                 if (!(m_renderingFlags & RestoreGraphicsContext)) {
-                    m_paintInfo->context->save();
+                    m_paintInfo->getContext()->save();
                     m_renderingFlags |= RestoreGraphicsContext;
                 }
-                m_paintInfo->context->setCompositeOperation(CompositeSourceOver, blendMode);
+                m_paintInfo->getContext()->setCompositeOperation(CompositeSourceOver, blendMode);
             }
-            m_paintInfo->context->beginTransparencyLayer(opacity);
+            m_paintInfo->getContext()->beginTransparencyLayer(opacity);
             m_renderingFlags |= EndOpacityLayer;
         }
     }
 
     ClipPathOperation* clipPathOperation = style->clipPath();
     if (clipPathOperation && clipPathOperation->getOperationType() == ClipPathOperation::SHAPE) {
         ShapeClipPathOperation* clipPath = static_cast<ShapeClipPathOperation*>(clipPathOperation);
-        m_paintInfo->context->clipPath(clipPath->path(object->objectBoundingBox()), clipPath->windRule());
+        m_paintInfo->getContext()->clipPath(clipPath->path(object->objectBoundingBox()), clipPath->windRule());
     }
 
     SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(m_object);
     if (!resources) {
         if (svgStyle->hasFilter())
             return;
 
         m_renderingFlags |= RenderingPrepared;
         return;
     }
 
     if (!isRenderingMask) {
         if (RenderSVGResourceMasker* masker = resources->masker()) {
-            if (!masker->applyResource(m_object, style, m_paintInfo->context, ApplyToDefaultMode))
+            GraphicsContext* context = m_paintInfo->getContext();
+            if (!masker->applyResource(m_object, style, context, ApplyToDefaultMode)) {
+                m_paintInfo->setContext(context);

[do-not-use, 2013/08/05 11:16:30]

IMHO, this results in less readable code. Maybe the context() getter could
getter a GraphicsContext*& instead of a GraphicsContext* so that we can keep the
code as it was?

I'd like another owner to confirm that this would be acceptable though.

                 return;
+            }
+            m_paintInfo->setContext(context);
         }
     }
 
     RenderSVGResourceClipper* clipper = resources->clipper();
     if (!clipPathOperation && clipper) {
-        if (!clipper->applyResource(m_object, style, m_paintInfo->context, ApplyToDefaultMode))
+        GraphicsContext* context = m_paintInfo->getContext();
+        if (!clipper->applyResource(m_object, style, context, ApplyToDefaultMode)) {
+            m_paintInfo->setContext(context);
             return;
+        }
+        m_paintInfo->setContext(context);
     }
 
     if (!isRenderingMask) {
         m_filter = resources->filter();
         if (m_filter) {
-            m_savedContext = m_paintInfo->context;
-            m_savedPaintRect = m_paintInfo->rect;
+            m_savedContext = m_paintInfo->getContext();
+            m_savedPaintRect = m_paintInfo->getRect();
             // Return with false here may mean that we don't need to draw the content
             // (because it was either drawn before or empty) but we still need to apply the filter.
             m_renderingFlags |= EndFilterLayer;
-            if (!m_filter->applyResource(m_object, style, m_paintInfo->context, ApplyToDefaultMode))
+            GraphicsContext* context = m_paintInfo->getContext();
+            if (!m_filter->applyResource(m_object, style, context, ApplyToDefaultMode)) {
+                m_paintInfo->setContext(context);
                 return;
+            }
+            m_paintInfo->setContext(context);
 
             // Since we're caching the resulting bitmap and do not invalidate it on repaint rect
             // changes, we need to paint the whole filter region. Otherwise, elements not visible
             // at the time of the initial paint (due to scrolling, window size, etc.) will never
             // be drawn.
-            m_paintInfo->rect = IntRect(m_filter->drawingRegion(m_object));
+            m_paintInfo->setRect(IntRect(m_filter->drawingRegion(m_object)));
         }
     }
 
     m_renderingFlags |= RenderingPrepared;
 }
 
 static AffineTransform& currentContentTransformation()
 {
     DEFINE_STATIC_LOCAL(AffineTransform, s_currentContentTransformation, ());
     return s_currentContentTransformation;
@@ skipping 140 matching lines @@
 }
 
 bool SVGRenderingContext::bufferForeground(OwnPtr<ImageBuffer>& imageBuffer)
 {
     ASSERT(m_paintInfo);
     ASSERT(m_object->isSVGImage());
     FloatRect boundingBox = m_object->objectBoundingBox();
 
     // Invalidate an existing buffer if the scale is not correct.
     if (imageBuffer) {
-        AffineTransform transform = m_paintInfo->context->getCTM(GraphicsContext::DefinitelyIncludeDeviceScale);
+        AffineTransform transform = m_paintInfo->getContext()->getCTM(GraphicsContext::DefinitelyIncludeDeviceScale);
         IntSize expandedBoundingBox = expandedIntSize(boundingBox.size());
         IntSize bufferSize(static_cast<int>(ceil(expandedBoundingBox.width() * transform.xScale())), static_cast<int>(ceil(expandedBoundingBox.height() * transform.yScale())));
         if (bufferSize != imageBuffer->internalSize())
             imageBuffer.clear();
     }
 
     // Create a new buffer and paint the foreground into it.
     if (!imageBuffer) {
-        if ((imageBuffer = m_paintInfo->context->createCompatibleBuffer(expandedIntSize(boundingBox.size()), true))) {
+        if ((imageBuffer = m_paintInfo->getContext()->createCompatibleBuffer(expandedIntSize(boundingBox.size()), true))) {
             GraphicsContext* bufferedRenderingContext = imageBuffer->context();
             bufferedRenderingContext->translate(-boundingBox.x(), -boundingBox.y());
             PaintInfo bufferedInfo(*m_paintInfo);
-            bufferedInfo.context = bufferedRenderingContext;
+            bufferedInfo.setContext(bufferedRenderingContext);
             toRenderSVGImage(m_object)->paintForeground(bufferedInfo);
         } else
             return false;
     }
 
-    m_paintInfo->context->drawImageBuffer(imageBuffer.get(), boundingBox);
+    m_paintInfo->getContext()->drawImageBuffer(imageBuffer.get(), boundingBox);
     return true;
 }
 
 }