Get rid of RenderLayer tracking in RenderSVGResourceContainer.

Source/core/rendering/svg/RenderSVGResourceContainer.cpp

 /*
  * 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.
  *
  * 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/RenderSVGResourceContainer.h"
 
+#include "core/frame/DeprecatedScheduleStyleRecalcDuringLayout.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/svg/SVGRenderingContext.h"
 #include "core/rendering/svg/SVGResourcesCache.h"
 #include "core/svg/SVGGraphicsElement.h"
 
 #include "wtf/TemporaryChange.h"
 
 namespace blink {
 
@@ skipping 58 matching lines @@
     // Remove old id, that is guaranteed to be present in cache.
     SVGDocumentExtensions& extensions = svgExtensionsFromElement(element());
     extensions.removeResource(m_id);
     m_id = element()->getIdAttribute();
 
     registerResource();
 }
 
 void RenderSVGResourceContainer::markAllClientsForInvalidation(InvalidationMode mode)
 {
-    if ((m_clients.isEmpty() && m_clientLayers.isEmpty()) || m_isInvalidating)
+    if ((m_clients.isEmpty()) || m_isInvalidating)
         return;
 
     if (m_invalidationMask & mode)
         return;
 
     m_invalidationMask |= mode;
     m_isInvalidating = true;
     bool needsLayout = mode == LayoutAndBoundariesInvalidation;
     bool markForInvalidation = mode != ParentOnlyInvalidation;
 
     HashSet<RenderObject*>::iterator end = m_clients.end();
     for (HashSet<RenderObject*>::iterator it = m_clients.begin(); it != end; ++it) {
         RenderObject* client = *it;
         if (client->isSVGResourceContainer()) {
             toRenderSVGResourceContainer(client)->removeAllClientsFromCache(markForInvalidation);
             continue;
         }
 
         if (markForInvalidation)
             markClientForInvalidation(client, mode);
 
         RenderSVGResource::markForLayoutAndParentResourceInvalidation(client, needsLayout);
     }
 
-    markAllClientLayersForInvalidation();
-
     m_isInvalidating = false;
 }
 
-void RenderSVGResourceContainer::markAllClientLayersForInvalidation()
-{
-    HashSet<RenderLayer*>::iterator layerEnd = m_clientLayers.end();
-    for (HashSet<RenderLayer*>::iterator it = m_clientLayers.begin(); it != layerEnd; ++it)
-        (*it)->filterNeedsPaintInvalidation();
-}
-
 void RenderSVGResourceContainer::markClientForInvalidation(RenderObject* client, InvalidationMode mode)
 {
     ASSERT(client);
     ASSERT(!m_clients.isEmpty());
 
+    {
+        DeprecatedScheduleStyleRecalcDuringLayout marker(client->document().lifecycle());
+        // It's possible for scheduleSVGFilterLayerUpdateHack to schedule a style recalc, which
+        // is a problem because this function can be called while performing layout.
+        // Presumably this represents an illegal data flow of layout or compositing
+        // information into the style system.
+        toElement(client->node())->scheduleSVGFilterLayerUpdateHack();
+    }
+
     switch (mode) {
     case LayoutAndBoundariesInvalidation:
     case BoundariesInvalidation:
         client->setNeedsBoundariesUpdate();
         break;
     case RepaintInvalidation:
         if (client->view()) {
             if (frameView()->isInPerformLayout())
                 client->setShouldDoFullPaintInvalidation(true);
             else
@@ skipping 12 matching lines @@
     clearInvalidationMask();
 }
 
 void RenderSVGResourceContainer::removeClient(RenderObject* client)
 {
     ASSERT(client);
     removeClientFromCache(client, false);
     m_clients.remove(client);
 }
 
-void RenderSVGResourceContainer::addClientRenderLayer(Node* node)
-{
-    ASSERT(node);
-    if (!node->renderer() || !node->renderer()->hasLayer())
-        return;
-    m_clientLayers.add(toRenderLayerModelObject(node->renderer())->layer());
-    clearInvalidationMask();
-}
-
-void RenderSVGResourceContainer::addClientRenderLayer(RenderLayer* client)
-{
-    ASSERT(client);
-    m_clientLayers.add(client);
-    clearInvalidationMask();
-}
-
-void RenderSVGResourceContainer::removeClientRenderLayer(RenderLayer* client)
-{
-    ASSERT(client);
-    m_clientLayers.remove(client);
-}
-
 void RenderSVGResourceContainer::invalidateCacheAndMarkForLayout(SubtreeLayoutScope* layoutScope)
 {
     if (selfNeedsLayout())
         return;
 
     setNeedsLayoutAndFullPaintInvalidation(MarkContainingBlockChain, layoutScope);
 
     if (everHadLayout())
         removeAllClientsFromCache();
 }
@@ skipping 70 matching lines @@
     if (!object->isSVGShape())
         return resourceTransform;
 
     SVGGraphicsElement* element = toSVGGraphicsElement(object->node());
     AffineTransform transform = element->getScreenCTM(SVGGraphicsElement::DisallowStyleUpdate);
     transform *= resourceTransform;
     return transform;
 }
 
 }