Use refs for GraphicsContext

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 "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/DrawingDisplayItem.h"
 #include "platform/graphics/paint/PaintController.h"
 
 #define CHECK_CTM_FOR_TRANSFORMED_IMAGEFILTER
 
 namespace blink {
 
 GraphicsContext* SVGFilterRecordingContext::beginContent(FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::Initial);
 
-    GraphicsContext* context = paintingContext();
+    GraphicsContext* context = &paintingContext();
 
     // Create a new context so the contents of the filter can be drawn and cached.
     m_paintController = PaintController::create();
     m_context = adoptPtr(new GraphicsContext(*m_paintController));
     context = m_context.get();
 
     filterData->m_state = FilterData::RecordingContent;
     return context;
 }
 
 void SVGFilterRecordingContext::endContent(FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::RecordingContent);
 
     SourceGraphic* sourceGraphic = filterData->filter->sourceGraphic();
     ASSERT(sourceGraphic);
 
-    GraphicsContext* context = paintingContext();
+    GraphicsContext* context = &paintingContext();
 
     // Use the context that contains the filtered content.
     ASSERT(m_paintController);
     ASSERT(m_context);
     context = m_context.get();
     context->beginRecording(filterData->filter->filterRegion());
     m_paintController->commitNewDisplayItems();
     m_paintController->paintArtifact().replay(*context);
 
     sourceGraphic->setPicture(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(const LayoutObject& object, GraphicsContext* context, FilterData* filterData)
+static void paintFilteredContent(const LayoutObject& object, GraphicsContext& context, FilterData* filterData)
 {
     ASSERT(filterData->m_state == FilterData::ReadyToPaint);
     ASSERT(filterData->filter->sourceGraphic());
 
     filterData->m_state = FilterData::PaintingFilter;
 
     SkiaImageFilterBuilder builder;
     RefPtr<SkImageFilter> imageFilter = builder.build(filterData->filter->lastEffect(), ColorSpaceDeviceRGB);
     FloatRect boundaries = filterData->filter->filterRegion();
-    context->save();
+    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->maxEffectRect()));
 
 #ifdef CHECK_CTM_FOR_TRANSFORMED_IMAGEFILTER
     // TODO: Remove this workaround once skew/rotation support is added in Skia
     // (https://code.google.com/p/skia/issues/detail?id=3288, crbug.com/446935).
     // If the CTM contains rotation or shearing, apply the filter to
     // the unsheared/unrotated matrix, and do the shearing/rotation
     // as a final pass.
     AffineTransform ctm = SVGLayoutSupport::deprecatedCalculateTransformToLayer(&object);
     if (ctm.b() || ctm.c()) {
         AffineTransform scaleAndTranslate;
         scaleAndTranslate.translate(ctm.e(), ctm.f());
         scaleAndTranslate.scale(ctm.xScale(), ctm.yScale());
         ASSERT(scaleAndTranslate.isInvertible());
         AffineTransform shearAndRotate = scaleAndTranslate.inverse();
         shearAndRotate.multiply(ctm);
-        context->concatCTM(shearAndRotate.inverse());
+        context.concatCTM(shearAndRotate.inverse());
         imageFilter = builder.buildTransform(shearAndRotate, imageFilter.get());
     }
 #endif
 
-    context->beginLayer(1, SkXfermode::kSrcOver_Mode, &boundaries, ColorFilterNone, imageFilter.get());
-    context->endLayer();
-    context->restore();
+    context.beginLayer(1, SkXfermode::kSrcOver_Mode, &boundaries, ColorFilterNone, imageFilter.get());
+    context.endLayer();
+    context.restore();
 
     filterData->m_state = FilterData::ReadyToPaint;
 }
 
 GraphicsContext* SVGFilterPainter::prepareEffect(const LayoutObject& object, SVGFilterRecordingContext& recordingContext)
 {
-    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;
 
         if (filterData->m_state == FilterData::RecordingContent)
@@ skipping 48 matching lines @@
 
         // 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)
             recordingContext.endContent(filterData);
 
         if (filterData->m_state == FilterData::RecordingContentCycleDetected)
             filterData->m_state = FilterData::RecordingContent;
     }
 
-    GraphicsContext* context = recordingContext.paintingContext();
-    ASSERT(context);
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*context, object, DisplayItem::SVGFilter, LayoutPoint()))
+    GraphicsContext& context = recordingContext.paintingContext();
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(context, object, DisplayItem::SVGFilter, LayoutPoint()))
         return;
 
     // TODO(chrishtr): stop using an infinite rect, and instead bound the filter.
-    LayoutObjectDrawingRecorder recorder(*context, object, DisplayItem::SVGFilter, LayoutRect::infiniteIntRect(), LayoutPoint());
+    LayoutObjectDrawingRecorder recorder(context, object, DisplayItem::SVGFilter, LayoutRect::infiniteIntRect(), LayoutPoint());
     if (filterData && filterData->m_state == FilterData::ReadyToPaint)
         paintFilteredContent(object, context, filterData);
 }
 
 }