Factor painting code for filters out of FilterEffectRenderer into FilterPainter.

Source/core/paint/LayerPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/LayerPainter.h"
 
 #include "core/frame/Settings.h"
 #include "core/page/Page.h"
+#include "core/paint/FilterPainter.h"
 #include "core/rendering/ClipPathOperation.h"
 #include "core/rendering/FilterEffectRenderer.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/svg/RenderSVGResourceClipper.h"
 
 namespace blink {
 
@@ skipping 249 matching lines @@
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
     // so it will be tested against as we descend through the renderers.
     RenderObject* paintingRootForRenderer = 0;
     if (localPaintingInfo.paintingRoot && !m_renderLayer.renderer()->isDescendantOf(localPaintingInfo.paintingRoot))
         paintingRootForRenderer = localPaintingInfo.paintingRoot;
 
     { // Begin block for the lifetime of any filter clip.
         OwnPtr<ClipRecorder> clipRecorder;
+        FilterPainter filterPainter(m_renderLayer);
         if (haveFilterEffect) {
             ASSERT(m_renderLayer.filterInfo());
 
             if (!rootRelativeBoundsComputed)
                 rootRelativeBounds = m_renderLayer.physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
 
             // Do transparency and clipping before starting filter processing.
             if (haveTransparency) {
                 // If we have a filter and transparency, we have to eagerly start a transparency layer here, rather than risk a child layer lazily starts one after filter processing.
                 beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
             }
 
             // We'll handle clipping to the dirty rect before filter rasterization.
             // Filter processing will automatically expand the clip rect and the offscreen to accommodate any filter outsets.
             // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
             ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
 
             if (needsToClip(localPaintingInfo, backgroundRect)) {
                 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, DisplayItem::ClipLayerFilter, backgroundRect));
                 applyRoundedRectClips(localPaintingInfo, context, backgroundRect, paintFlags, *clipRecorder);
             }
 
             // Subsequent code should not clip to the dirty rect, since we've already
             // done it above, and doing it later will defeat the outsets.
             localPaintingInfo.clipToDirtyRect = false;
-            haveFilterEffect = m_renderLayer.filterRenderer()->beginFilterEffect(context, rootRelativeBounds);
+            haveFilterEffect = filterPainter.beginFilterEffect(context, rootRelativeBounds);
             if (!haveFilterEffect) {
                 // If the the filter failed to start, undo the clip immediately
                 clipRecorder.clear();
             }
         }
 
         ASSERT(!(localPaintingInfo.paintBehavior & PaintBehaviorForceBlackText));
 
         bool shouldPaintBackground = isPaintingCompositedBackground && shouldPaintContent && !selectionOnly;
         bool shouldPaintNegZOrderList = (isPaintingScrollingContent && isPaintingOverflowContents) || (!isPaintingScrollingContent && isPaintingCompositedBackground);
@@ skipping 25 matching lines @@
 
         if (shouldPaintNormalFlowAndPosZOrderLists)
             paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
 
         if (shouldPaintOverlayScrollbars)
             paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags);
 
         if (haveFilterEffect) {
             // Apply the correct clipping (ie. overflow: hidden).
             // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
-            m_renderLayer.filterRenderer()->endFilterEffect(context);
+            filterPainter.endFilterEffect(context);

[mstensho (USE GERRIT), 2014/11/11 08:15:29]

Can't you just have ~FilterPainter() do this job, to achieve a half-RAII
experience? :)

You could store |context| as a member when calling beginFilterEffect().

         }
     } // Filter clip block
 
     bool shouldPaintMask = (paintFlags & PaintLayerPaintingCompositingMaskPhase) && shouldPaintContent && m_renderLayer.renderer()->hasMask() && !selectionOnly;
     bool shouldPaintClippingMask = (paintFlags & PaintLayerPaintingChildClippingMaskPhase) && shouldPaintContent && !selectionOnly;
 
     if (shouldPaintMask)
         paintMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer, paintFlags);
 
     if (shouldPaintClippingMask) {
@@ skipping 485 matching lines @@
             clipRecorder = adoptPtr(new ClipRecorder(m_renderLayer.parent(), context, DisplayItem::ClipLayerFragmentParent, clipRect));
             // FIXME: why should we have to deal with rounded rect clips here at all?
             LayerPainter(*m_renderLayer.parent()).applyRoundedRectClips(paintingInfo, context, clipRect, paintFlags, *clipRecorder);
         }
 
         paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragment.paginationOffset);
     }
 }
 
 } // namespace blink