Disentangle filter content recording state from FilterData

Source/core/paint/SVGFilterPainter.cpp

 // Copyright 2015 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/SVGFilterPainter.h"
 
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/CompositingRecorder.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/TransformRecorder.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
 #include "platform/graphics/filters/SourceGraphic.h"
 #include "platform/graphics/paint/CompositingDisplayItem.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 
 #define CHECK_CTM_FOR_TRANSFORMED_IMAGEFILTER
 
 namespace blink {
 
-static GraphicsContext* beginRecordingContent(GraphicsContext* context, FilterData* filterData)
+GraphicsContext* SVGFilterRecordingContext::beginContent(FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::Initial);
 
+    GraphicsContext* context = paintingContext();
+
     // For slimming paint we need to create a new context so the contents of the
     // filter can be drawn and cached.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
-        filterData->m_displayItemList = DisplayItemList::create();
-        filterData->m_context = adoptPtr(new GraphicsContext(filterData->m_displayItemList.get()));
-        context = filterData->m_context.get();
+        m_displayItemList = DisplayItemList::create();
+        m_context = adoptPtr(new GraphicsContext(m_displayItemList.get()));
+        context = m_context.get();
     } else {
         context->beginRecording(filterData->filter->filterRegion());
     }
 
     filterData->m_state = FilterData::RecordingContent;
     return context;
 }
 
-static void endRecordingContent(GraphicsContext* context, FilterData* filterData)
+void SVGFilterRecordingContext::endContent(FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::RecordingContent);
 
     // FIXME: maybe filterData should just hold onto SourceGraphic after creation?
     SourceGraphic* sourceGraphic = static_cast<SourceGraphic*>(filterData->builder->getEffectById(SourceGraphic::effectName()));
     ASSERT(sourceGraphic);
 
+    GraphicsContext* context = paintingContext();
+
     // For slimming paint we need to use the context that contains the filtered
     // content.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
-        ASSERT(filterData->m_displayItemList);
-        ASSERT(filterData->m_context);
-        context = filterData->m_context.get();
+        ASSERT(m_displayItemList);
+        ASSERT(m_context);
+        context = m_context.get();
         context->beginRecording(filterData->filter->filterRegion());
-        filterData->m_displayItemList->commitNewDisplayItemsAndReplay(*context);
+        m_displayItemList->commitNewDisplayItemsAndReplay(*context);
     }
 
     sourceGraphic->setPicture(context->endRecording());
 
     // Content is cached by the source graphic so temporaries can be freed.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
-        filterData->m_displayItemList = nullptr;
-        filterData->m_context = nullptr;
+        m_displayItemList = nullptr;
+        m_context = nullptr;
     }
 
     filterData->m_state = FilterData::ReadyToPaint;
 }
 
-static void paintFilteredContent(LayoutObject& object, GraphicsContext* context, FilterData* filterData, SVGFilterElement* filterElement)
+static void paintFilteredContent(LayoutObject& object, GraphicsContext* context, FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::ReadyToPaint);
     ASSERT(filterData->builder->getEffectById(SourceGraphic::effectName()));
 
     filterData->m_state = FilterData::PaintingFilter;
 
     SkiaImageFilterBuilder builder;
     RefPtr<SkImageFilter> imageFilter = builder.build(filterData->builder->lastEffect(), ColorSpaceDeviceRGB);
     FloatRect boundaries = filterData->filter->filterRegion();
     context->save();
@@ skipping 21 matching lines @@
     }
 #endif
 
     context->beginLayer(1, SkXfermode::kSrcOver_Mode, &boundaries, ColorFilterNone, imageFilter.get());
     context->endLayer();
     context->restore();
 
     filterData->m_state = FilterData::ReadyToPaint;
 }
 
-GraphicsContext* SVGFilterPainter::prepareEffect(LayoutObject& object, GraphicsContext* context)
+GraphicsContext* SVGFilterPainter::prepareEffect(LayoutObject& object, SVGFilterRecordingContext& recordingContext)
 {
-    ASSERT(context);
+    ASSERT(recordingContext.paintingContext());
 
     m_filter.clearInvalidationMask();
 
     if (FilterData* filterData = m_filter.getFilterDataForLayoutObject(&object)) {
         // If the filterData already exists we do not need to record the content
         // to be filtered. This can occur if the content was previously recorded
         // or we are in a cycle.
         if (filterData->m_state == FilterData::PaintingFilter)
             filterData->m_state = FilterData::PaintingFilterCycleDetected;
 
@@ skipping 23 matching lines @@
         return nullptr;
 
     FilterEffect* lastEffect = filterData->builder->lastEffect();
     if (!lastEffect)
         return nullptr;
 
     lastEffect->determineFilterPrimitiveSubregion(ClipToFilterRegion);
 
     FilterData* data = filterData.get();
     m_filter.setFilterDataForLayoutObject(&object, filterData.release());
-    return beginRecordingContent(context, data);
+    return recordingContext.beginContent(data);
 }
 
-void SVGFilterPainter::finishEffect(LayoutObject& object, GraphicsContext* context)
+void SVGFilterPainter::finishEffect(LayoutObject& object, SVGFilterRecordingContext& recordingContext)
 {
-    ASSERT(context);
-
     FilterData* filterData = m_filter.getFilterDataForLayoutObject(&object);
     if (filterData) {
         // A painting cycle can occur when an FeImage references a source that
         // makes use of the FeImage itself. This is the first place we would hit
         // the cycle so we reset the state and continue.
         if (filterData->m_state == FilterData::PaintingFilterCycleDetected)
             filterData->m_state = FilterData::PaintingFilter;
 
         // Check for RecordingContent here because we may can be re-painting
         // without re-recording the contents to be filtered.
         if (filterData->m_state == FilterData::RecordingContent)
-            endRecordingContent(context, filterData);
+            recordingContext.endContent(filterData);
 
         if (filterData->m_state == FilterData::RecordingContentCycleDetected)
             filterData->m_state = FilterData::RecordingContent;
     }
 
+    GraphicsContext* context = recordingContext.paintingContext();
+    ASSERT(context);
+
     LayoutObjectDrawingRecorder recorder(*context, object, DisplayItem::SVGFilter, LayoutRect::infiniteIntRect());
     if (recorder.canUseCachedDrawing())
         return;
 
     if (filterData && filterData->m_state == FilterData::ReadyToPaint)
-        paintFilteredContent(object, context, filterData, toSVGFilterElement(m_filter.element()));
+        paintFilteredContent(object, context, filterData);
 }
 
 }