Replace FilterEffect::maxEffectRect() with absoluteBounds()

third_party/WebKit/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 "core/paint/SVGFilterPainter.h"
 
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/paint/FilterEffectBuilder.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
 #include "platform/graphics/filters/SourceGraphic.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 GraphicsContext* SVGFilterRecordingContext::beginContent(FilterData* filterData)
 {
-    ASSERT(filterData->m_state == FilterData::Initial);
+    DCHECK_EQ(filterData->m_state, FilterData::Initial);
 
     // Create a new context so the contents of the filter can be drawn and cached.
     m_paintController = PaintController::create();
     m_context = wrapUnique(new GraphicsContext(*m_paintController));
 
     filterData->m_state = FilterData::RecordingContent;
     return m_context.get();
 }
 
 void SVGFilterRecordingContext::endContent(FilterData* filterData)
 {
-    ASSERT(filterData->m_state == FilterData::RecordingContent);
+    DCHECK_EQ(filterData->m_state, FilterData::RecordingContent);
 
     SourceGraphic* sourceGraphic = filterData->filter->getSourceGraphic();
-    ASSERT(sourceGraphic);
+    DCHECK(sourceGraphic);
 
     // Use the context that contains the filtered content.
-    ASSERT(m_paintController);
-    ASSERT(m_context);
+    DCHECK(m_paintController);
+    DCHECK(m_context);
     m_context->beginRecording(filterData->filter->filterRegion());
     m_paintController->commitNewDisplayItems();
     m_paintController->paintArtifact().replay(*m_context);
 
     SkiaImageFilterBuilder::buildSourceGraphic(sourceGraphic, m_context->endRecording());
 
     // Content is cached by the source graphic so temporaries can be freed.
     m_paintController = nullptr;
     m_context = nullptr;
 
     filterData->m_state = FilterData::ReadyToPaint;
 }
 
 static void paintFilteredContent(GraphicsContext& context, FilterData* filterData)
 {
-    ASSERT(filterData->m_state == FilterData::ReadyToPaint);
-    ASSERT(filterData->filter->getSourceGraphic());
+    DCHECK_EQ(filterData->m_state, FilterData::ReadyToPaint);
+    DCHECK(filterData->filter->getSourceGraphic());
 
     filterData->m_state = FilterData::PaintingFilter;
 
-    sk_sp<SkImageFilter> imageFilter = SkiaImageFilterBuilder::build(filterData->filter->lastEffect(), ColorSpaceDeviceRGB);
-    FloatRect boundaries = filterData->filter->filterRegion();
+    FilterEffect* lastEffect = filterData->filter->lastEffect();
+    sk_sp<SkImageFilter> imageFilter = SkiaImageFilterBuilder::build(lastEffect, ColorSpaceDeviceRGB);
     context.save();
 
     // Clip drawing of filtered image to the minimum required paint rect.
-    FilterEffect* lastEffect = filterData->filter->lastEffect();
-    context.clipRect(lastEffect->determineAbsolutePaintRect(lastEffect->maxEffectRect()));
+    context.clipRect(lastEffect->determineAbsolutePaintRect(lastEffect->absoluteBounds()));
 
+    FloatRect boundaries = filterData->filter->filterRegion();
     context.beginLayer(1, SkXfermode::kSrcOver_Mode, &boundaries, ColorFilterNone, std::move(imageFilter));
     context.endLayer();
     context.restore();
 
     filterData->m_state = FilterData::ReadyToPaint;
 }
 
 GraphicsContext* SVGFilterPainter::prepareEffect(const LayoutObject& object, SVGFilterRecordingContext& recordingContext)
 {
     m_filter.clearInvalidationMask();
@@ skipping 12 matching lines @@
     }
 
     const FloatRect referenceBox = object.objectBoundingBox();
     SVGFilterGraphNodeMap* nodeMap = SVGFilterGraphNodeMap::create();
     Filter* filter = FilterEffectBuilder::buildReferenceFilter(toSVGFilterElement(*m_filter.element()), referenceBox, nullptr, nullptr, nullptr, 1, nodeMap);
     if (!filter || !filter->lastEffect())
         return nullptr;
 
     IntRect sourceRegion = enclosingIntRect(intersection(filter->filterRegion(), object.strokeBoundingBox()));
     filter->getSourceGraphic()->setSourceRect(sourceRegion);
-    filter->lastEffect()->determineMaximumEffectRect();
 
     FilterData* filterData = FilterData::create();
     filterData->filter = filter;
     filterData->nodeMap = nodeMap;
 
     // TODO(pdr): Can this be moved out of painter?
     m_filter.setFilterDataForLayoutObject(const_cast<LayoutObject*>(&object), filterData);
     return recordingContext.beginContent(filterData);
 }
 
@@ skipping 20 matching lines @@
     if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(context, object, DisplayItem::kSVGFilter))
         return;
 
     FloatRect filterRegion = filterData ? filterData->filter->filterRegion() : FloatRect();
     LayoutObjectDrawingRecorder recorder(context, object, DisplayItem::kSVGFilter, filterRegion);
     if (filterData && filterData->m_state == FilterData::ReadyToPaint)
         paintFilteredContent(context, filterData);
 }
 
 } // namespace blink