Merge 131488

Source/WebCore/rendering/svg/RenderSVGResourceFilter.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.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
@@ skipping 39 matching lines @@
 #include "SourceAlpha.h"
 #include "SourceGraphic.h"
 
 #include <wtf/UnusedParam.h>
 #include <wtf/Vector.h>
 
 using namespace std;
 
 namespace WebCore {
 
+class ApplyingFilterEffectGuard {
+public:
+    ApplyingFilterEffectGuard(FilterData* data)
+        : m_filterData(data)
+    {
+        // The guard must be constructed when the filter is not applying.
+        ASSERT(!m_filterData->isApplying);
+        m_filterData->isApplying = true;
+    }
+
+    ~ApplyingFilterEffectGuard()
+    {
+        ASSERT(m_filterData->isApplying);
+        m_filterData->isApplying = false;
+    }
+
+    FilterData* m_filterData;
+};
+
 RenderSVGResourceType RenderSVGResourceFilter::s_resourceType = FilterResourceType;
 
 RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement* node)
     : RenderSVGResourceContainer(node)
 {
 }
 
 RenderSVGResourceFilter::~RenderSVGResourceFilter()
 {
     if (m_filter.isEmpty())
@@ skipping 76 matching lines @@
 bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
 {
     ASSERT(object);
     ASSERT(context);
     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
 
     // Returning false here, to avoid drawings onto the context. We just want to
     // draw the stored filter output, not the unfiltered object as well.
     if (m_filter.contains(object)) {
         FilterData* filterData = m_filter.get(object);
-        if (filterData->builded)
+        if (filterData->isBuilt || filterData->isApplying)
             return false;
 
         delete m_filter.take(object); // Oops, have to rebuild, go through normal code path
     }
 
     OwnPtr<FilterData> filterData(adoptPtr(new FilterData));
     FloatRect targetBoundingBox = object->objectBoundingBox();
 
     SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
     filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(filterElement, filterElement->filterUnits(), targetBoundingBox);
@@ skipping 104 matching lines @@
 
     FilterData* filterData = m_filter.get(object);
     if (!filterData)
         return;
 
     if (filterData->markedForRemoval) {
         delete m_filter.take(object);
         return;
     }
 
-    if (!filterData->builded) {
+    // We have a cycle if we are already applying the data.
+    // This can occur due to FeImage referencing a source that makes use of the FEImage itself.
+    if (filterData->isApplying)
+        return;
+
+    if (!filterData->isBuilt) {
         if (!filterData->savedContext) {
             removeClientFromCache(object);
             return;
         }
 
         context = filterData->savedContext;
         filterData->savedContext = 0;
     }
 
+    ApplyingFilterEffectGuard isApplyingGuard(filterData);
+
     FilterEffect* lastEffect = filterData->builder->lastEffect();
 
     if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
         // This is the real filtering of the object. It just needs to be called on the
         // initial filtering process. We just take the stored filter result on a
         // second drawing.
-        if (!filterData->builded)
+        if (!filterData->isBuilt)
             filterData->filter->setSourceImage(filterData->sourceGraphicBuffer.release());
 
-        // Always true if filterData is just built (filterData->builded is false).
+        // Always true if filterData is just built (filterData->isBuilt is false).
         if (!lastEffect->hasResult()) {
             lastEffect->apply();
             lastEffect->correctFilterResultIfNeeded();
 #if !USE(CG)
             ImageBuffer* resultImage = lastEffect->asImageBuffer();
             if (resultImage)
                 resultImage->transformColorSpace(lastEffect->colorSpace(), ColorSpaceDeviceRGB);
 #endif
         }
-        filterData->builded = true;
+        filterData->isBuilt = true;
 
         ImageBuffer* resultImage = lastEffect->asImageBuffer();
         if (resultImage) {
             context->concatCTM(filterData->shearFreeAbsoluteTransform.inverse());
 
             context->scale(FloatSize(1 / filterData->filter->filterResolution().width(), 1 / filterData->filter->filterResolution().height()));
             context->drawImageBuffer(resultImage, object->style()->colorSpace(), lastEffect->absolutePaintRect());
             context->scale(filterData->filter->filterResolution());
 
             context->concatCTM(filterData->shearFreeAbsoluteTransform);
@@ skipping 11 matching lines @@
 }
 
 void RenderSVGResourceFilter::primitiveAttributeChanged(RenderObject* object, const QualifiedName& attribute)
 {
     HashMap<RenderObject*, FilterData*>::iterator it = m_filter.begin();
     HashMap<RenderObject*, FilterData*>::iterator end = m_filter.end();
     SVGFilterPrimitiveStandardAttributes* primitve = static_cast<SVGFilterPrimitiveStandardAttributes*>(object->node());
 
     for (; it != end; ++it) {
         FilterData* filterData = it->second;
-        if (!filterData->builded)
+        if (!filterData->isBuilt)
             continue;
 
         SVGFilterBuilder* builder = filterData->builder.get();
         FilterEffect* effect = builder->effectByRenderer(object);
         if (!effect)
             continue;
         // Since all effects shares the same attribute value, all
         // or none of them will be changed.
         if (!primitve->setFilterEffectAttribute(effect, attribute))
             return;
         builder->clearResultsRecursive(effect);
 
         // Repaint the image on the screen.
         markClientForInvalidation(it->first, RepaintInvalidation);
     }
 }
 
 }
 #endif