ImageBuffer-less SVG masking and clipping.

Source/core/rendering/svg/RenderSVGResourceMasker.cpp

 /*
  * 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
  * 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 
 #include "core/rendering/svg/RenderSVGResourceMasker.h"
 
 #include "core/platform/graphics/FloatRect.h"
 #include "core/platform/graphics/GraphicsContext.h"
+#include "core/platform/graphics/GraphicsContextStateSaver.h"
 #include "core/platform/graphics/ImageBuffer.h"
 #include "core/platform/graphics/transforms/AffineTransform.h"
 #include "core/rendering/svg/RenderSVGResource.h"
 #include "core/rendering/svg/SVGRenderingContext.h"
 #include "core/svg/SVGElement.h"
 #include "core/svg/SVGMaskElement.h"
 #include "core/svg/SVGUnitTypes.h"
 
 #include "wtf/UnusedParam.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 RenderSVGResourceType RenderSVGResourceMasker::s_resourceType = MaskerResourceType;
 
 RenderSVGResourceMasker::RenderSVGResourceMasker(SVGMaskElement* node)
     : RenderSVGResourceContainer(node)
 {
 }
 
 RenderSVGResourceMasker::~RenderSVGResourceMasker()
 {
-    if (m_masker.isEmpty())
-        return;
-
-    deleteAllValues(m_masker);
-    m_masker.clear();
 }
 
 void RenderSVGResourceMasker::removeAllClientsFromCache(bool markForInvalidation)
 {
     m_maskContentBoundaries = FloatRect();
-    if (!m_masker.isEmpty()) {
-        deleteAllValues(m_masker);
-        m_masker.clear();
-    }
-
     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
 }
 
 void RenderSVGResourceMasker::removeClientFromCache(RenderObject* client, bool markForInvalidation)
 {
     ASSERT(client);
-
-    if (m_masker.contains(client))
-        delete m_masker.take(client);
-
     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
 }
 
-bool RenderSVGResourceMasker::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
+bool RenderSVGResourceMasker::applyResource(RenderObject* object, RenderStyle*,
+    GraphicsContext*& context, unsigned short resourceMode)
 {
     ASSERT(object);
     ASSERT(context);
+    ASSERT(style());
     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
-
-    bool missingMaskerData = !m_masker.contains(object);
-    if (missingMaskerData)
-        m_masker.set(object, new MaskerData);
-
-    MaskerData* maskerData = m_masker.get(object);
-
-    AffineTransform absoluteTransform;
-    SVGRenderingContext::calculateTransformationToOutermostCoordinateSystem(object, absoluteTransform);
+    ASSERT_WITH_SECURITY_IMPLICATION(!needsLayout());
 
     FloatRect repaintRect = object->repaintRectInLocalCoordinates();
+    if (repaintRect.isEmpty() || !node()->hasChildNodes())
+        return false;
 
-    if (!maskerData->maskImage && !repaintRect.isEmpty()) {
-        SVGMaskElement* maskElement = toSVGMaskElement(node());
-        if (!maskElement)
-            return false;
+    const SVGRenderStyle* svgStyle = style()->svgStyle();
+    ASSERT(svgStyle);
+    ColorSpace colorSpace = svgStyle->colorInterpolation() == CI_LINEARRGB
+        ? ColorSpaceLinearRGB
+        : ColorSpaceDeviceRGB;
 
-        ASSERT(style());
-        const SVGRenderStyle* svgStyle = style()->svgStyle();
-        ASSERT(svgStyle);
-        ColorSpace colorSpace = svgStyle->colorInterpolation() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB;
-        if (!SVGRenderingContext::createImageBuffer(repaintRect, absoluteTransform, maskerData->maskImage, Unaccelerated))
-            return false;
+    // Mask layer start.
+    context->beginTransparencyLayer(1, &repaintRect);
+    {
+        // Draw the mask with color conversion (when needed).
+        GraphicsContextStateSaver maskContentSaver(*context);
+        context->setColorSpaceConversion(ColorSpaceDeviceRGB, colorSpace);
 
-        if (!drawContentIntoMaskImage(maskerData, colorSpace, maskElement, object)) {
-            maskerData->maskImage.clear();
-        }
+        drawMaskContent(context, object->objectBoundingBox());
     }
 
-    if (!maskerData->maskImage)
-        return false;
-
-    SVGRenderingContext::clipToImageBuffer(context, absoluteTransform, repaintRect, maskerData->maskImage, missingMaskerData);
-    return true;
-}
-
-bool RenderSVGResourceMasker::drawContentIntoMaskImage(MaskerData* maskerData, ColorSpace colorSpace, const SVGMaskElement* maskElement, RenderObject* object)
-{
-    GraphicsContext* maskImageContext = maskerData->maskImage->context();
-    ASSERT(maskImageContext);
-
-    // Eventually adjust the mask image context according to the target objectBoundingBox.
-    AffineTransform maskContentTransformation;
-    if (maskElement->maskContentUnitsCurrentValue() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
-        FloatRect objectBoundingBox = object->objectBoundingBox();
-        maskContentTransformation.translate(objectBoundingBox.x(), objectBoundingBox.y());
-        maskContentTransformation.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
-        maskImageContext->concatCTM(maskContentTransformation);
-    }
-
-    // Draw the content into the ImageBuffer.
-    for (Node* node = maskElement->firstChild(); node; node = node->nextSibling()) {
-        RenderObject* renderer = node->renderer();
-        if (!node->isSVGElement() || !renderer)
-            continue;
-        if (renderer->needsLayout())
-            return false;
-        RenderStyle* style = renderer->style();
-        if (!style || style->display() == NONE || style->visibility() != VISIBLE)
-            continue;
-        SVGRenderingContext::renderSubtreeToImageBuffer(maskerData->maskImage.get(), renderer, maskContentTransformation);
-    }
-
-    maskerData->maskImage->transformColorSpace(ColorSpaceDeviceRGB, colorSpace);
-
-    ASSERT(style());
-    ASSERT(style()->svgStyle());
-    // Create the luminance mask.
-    if (style()->svgStyle()->maskType() == MT_LUMINANCE)
-        maskerData->maskImage->convertToLuminanceMask();
+    // Content layer start.
+    MaskType maskType = svgStyle->maskType() == MT_LUMINANCE ? LuminanceMaskType : AlphaMaskType;
+    context->beginMaskedLayer(repaintRect, maskType);
 
     return true;
 }
 
+void RenderSVGResourceMasker::postApplyResource(RenderObject*, GraphicsContext*& context,
+    unsigned short resourceMode, const Path*, const RenderSVGShape*)
+{
+    ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
+
+    // Transfer content layer -> mask layer (SrcIn)
+    context->endLayer();
+    // Transfer mask layer -> bg layer (SrcOver)
+    context->endLayer();
+}
+
+void RenderSVGResourceMasker::drawMaskContent(GraphicsContext* context, const FloatRect& targetBoundingBox)
+{
+    ASSERT(context);
+
+    // Adjust the mask image context according to the target objectBoundingBox.
+    AffineTransform maskContentTransformation;
+    if (toSVGMaskElement(node())->maskContentUnitsCurrentValue() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
+        maskContentTransformation.translate(targetBoundingBox.x(), targetBoundingBox.y());
+        maskContentTransformation.scaleNonUniform(targetBoundingBox.width(), targetBoundingBox.height());
+        context->concatCTM(maskContentTransformation);
+    }
+
+    for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
+        RenderObject* renderer = childNode->renderer();
+        if (!childNode->isSVGElement() || !renderer)
+            continue;
+        RenderStyle* style = renderer->style();
+        if (!style || style->display() == NONE || style->visibility() != VISIBLE)
+            continue;
+
+        SVGRenderingContext::renderSubtree(context, renderer, maskContentTransformation);
+    }
+}
+
 void RenderSVGResourceMasker::calculateMaskContentRepaintRect()
 {
     for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
         RenderObject* renderer = childNode->renderer();
         if (!childNode->isSVGElement() || !renderer)
             continue;
         RenderStyle* style = renderer->style();
         if (!style || style->display() == NONE || style->visibility() != VISIBLE)
              continue;
         m_maskContentBoundaries.unite(renderer->localToParentTransform().mapRect(renderer->repaintRectInLocalCoordinates()));
@@ skipping 21 matching lines @@
         transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
         transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
         maskRect = transform.mapRect(maskRect);
     }
 
     maskRect.intersect(maskBoundaries);
     return maskRect;
 }
 
 }