Use refs for GraphicsContext

third_party/WebKit/Source/core/paint/BoxPainter.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/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
@@ skipping 63 matching lines @@
 } // anonymous namespace
 
 void BoxPainter::paintBoxDecorationBackgroundWithRect(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutRect& paintRect)
 {
     const ComputedStyle& style = m_layoutBox.styleRef();
 
     // FIXME: For now we don't have notification on media buffered range change from media player
     // and miss paint invalidation on buffered range change. crbug.com/484288.
     Optional<DisplayItemCacheSkipper> cacheSkipper;
     if (style.appearance() == MediaSliderPart)
-        cacheSkipper.emplace(*paintInfo.context);
+        cacheSkipper.emplace(paintInfo.context);
 
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, paintOffset))
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, paintOffset))
         return;
 
-    LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintOffset), paintOffset);
+    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintOffset), paintOffset);
 
     BoxDecorationData boxDecorationData(m_layoutBox);
 
     // FIXME: Should eventually give the theme control over whether the box shadow should paint, since controls could have
     // custom shadows of their own.
     if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance))
         paintBoxShadow(paintInfo, paintRect, style, Normal);
 
-    GraphicsContextStateSaver stateSaver(*paintInfo.context, false);
+    GraphicsContextStateSaver stateSaver(paintInfo.context, false);
     if (bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
 
         stateSaver.save();
         FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
-        paintInfo.context->clipRoundedRect(border);
+        paintInfo.context.clipRoundedRect(border);
 
         if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
-            paintInfo.context->beginLayer();
+            paintInfo.context.beginLayer();
     }
 
     // If we have a native theme appearance, paint that before painting our background.
     // The theme will tell us whether or not we should also paint the CSS background.
     IntRect snappedPaintRect(pixelSnappedIntRect(paintRect));
     ThemePainter& themePainter = LayoutTheme::theme().painter();
     bool themePainted = boxDecorationData.hasAppearance && !themePainter.paint(m_layoutBox, paintInfo, snappedPaintRect);
     if (!themePainted) {
         paintBackground(paintInfo, paintRect, boxDecorationData.backgroundColor, boxDecorationData.bleedAvoidance);
 
         if (boxDecorationData.hasAppearance)
             themePainter.paintDecorations(m_layoutBox, paintInfo, snappedPaintRect);
     }
     paintBoxShadow(paintInfo, paintRect, style, Inset);
 
     // The theme will tell us whether or not we should also paint the CSS border.
     if (boxDecorationData.hasBorderDecoration
         && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().painter().paintBorderOnly(m_layoutBox, paintInfo, snappedPaintRect)))
         && !(m_layoutBox.isTable() && toLayoutTable(&m_layoutBox)->collapseBorders()))
         paintBorder(m_layoutBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance);
 
     if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
-        paintInfo.context->endLayer();
+        paintInfo.context.endLayer();
 }
 
 void BoxPainter::paintBackground(const PaintInfo& paintInfo, const LayoutRect& paintRect, const Color& backgroundColor, BackgroundBleedAvoidance bleedAvoidance)
 {
     if (m_layoutBox.isDocumentElement())
         return;
     if (m_layoutBox.backgroundStolenForBeingBody())
         return;
     if (m_layoutBox.boxDecorationBackgroundIsKnownToBeObscured())
         return;
@@ skipping 52 matching lines @@
         for (auto currentLayer = &fillLayer; currentLayer; currentLayer = currentLayer->next()) {
             reversedPaintList.append(currentLayer);
             if (currentLayer->composite() != CompositeSourceOver || currentLayer->blendMode() != WebBlendModeNormal)
                 shouldDrawBackgroundInSeparateBuffer = true;
         }
     }
 
     // TODO(trchen): We can optimize out isolation group if we have a non-transparent
     // background color and the bottom layer encloses all other layers.
 
-    GraphicsContext* context = paintInfo.context;
-    if (!context)
-        shouldDrawBackgroundInSeparateBuffer = false;
+    GraphicsContext& context = paintInfo.context;
 
     if (shouldDrawBackgroundInSeparateBuffer)
-        context->beginLayer();
+        context.beginLayer();
 
     for (auto it = reversedPaintList.rbegin(); it != reversedPaintList.rend(); ++it)
         paintFillLayer(paintInfo, c, **it, rect, bleedAvoidance, op, backgroundObject);
 
     if (shouldDrawBackgroundInSeparateBuffer)
-        context->endLayer();
+        context.endLayer();
 }
 
 void BoxPainter::paintFillLayer(const PaintInfo& paintInfo, const Color& c, const FillLayer& fillLayer, const LayoutRect& rect,
     BackgroundBleedAvoidance bleedAvoidance, SkXfermode::Mode op, const LayoutObject* backgroundObject)
 {
     BoxPainter::paintFillLayerExtended(m_layoutBox, paintInfo, c, fillLayer, rect, bleedAvoidance, 0, LayoutSize(), op, backgroundObject);
 }
 
-void BoxPainter::applyBoxShadowForBackground(GraphicsContext* context, const LayoutObject& obj)
+void BoxPainter::applyBoxShadowForBackground(GraphicsContext& context, const LayoutObject& obj)
 {
     const ShadowList* shadowList = obj.style()->boxShadow();
     ASSERT(shadowList);
     for (size_t i = shadowList->shadows().size(); i--; ) {
         const ShadowData& boxShadow = shadowList->shadows()[i];
         if (boxShadow.style() != Normal)
             continue;
         FloatSize shadowOffset(boxShadow.x(), boxShadow.y());
-        context->setShadow(shadowOffset, boxShadow.blur(),
+        context.setShadow(shadowOffset, boxShadow.blur(),
             boxShadow.color().resolve(obj.resolveColor(CSSPropertyColor)),
             DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
         return;
     }
 }
 
 FloatRoundedRect BoxPainter::getBackgroundRoundedRect(const LayoutObject& obj, const LayoutRect& borderRect,
     const InlineFlowBox* box, LayoutUnit inlineBoxWidth, LayoutUnit inlineBoxHeight,
     bool includeLogicalLeftEdge, bool includeLogicalRightEdge)
 {
@@ skipping 41 matching lines @@
         FloatRoundedRect::Radii insetRadii(backgroundRoundedRect.radii());
         insetRadii.shrink(-insets.top(), -insets.bottom(), -insets.left(), -insets.right());
         return FloatRoundedRect(insetRect, insetRadii);
     }
 
     return getBackgroundRoundedRect(obj, borderRect, box, boxSize.width(), boxSize.height(), includeLogicalLeftEdge, includeLogicalRightEdge);
 }
 
 void BoxPainter::paintFillLayerExtended(const LayoutBoxModelObject& obj, const PaintInfo& paintInfo, const Color& color, const FillLayer& bgLayer, const LayoutRect& rect, BackgroundBleedAvoidance bleedAvoidance, const InlineFlowBox* box, const LayoutSize& boxSize, SkXfermode::Mode op, const LayoutObject* backgroundObject)
 {
-    GraphicsContext* context = paintInfo.context;
+    GraphicsContext& context = paintInfo.context;
     if (rect.isEmpty())
         return;
 
     bool includeLeftEdge = box ? box->includeLogicalLeftEdge() : true;
     bool includeRightEdge = box ? box->includeLogicalRightEdge() : true;
 
     bool hasRoundedBorder = obj.style()->hasBorderRadius() && (includeLeftEdge || includeRightEdge);
     bool clippedWithLocalScrolling = obj.hasOverflowClip() && bgLayer.attachment() == LocalBackgroundAttachment;
     bool isBorderFill = bgLayer.clip() == BorderFillBox;
     bool isBottomLayer = !bgLayer.next();
@@ skipping 18 matching lines @@
             bgImage = nullptr;
         }
     }
 
     // Fast path for drawing simple color backgrounds.
     if (!clippedWithLocalScrolling && !bgImage && isBorderFill && isBottomLayer) {
         if (!bgColor.alpha())
             return;
 
         bool boxShadowShouldBeAppliedToBackground = obj.boxShadowShouldBeAppliedToBackground(bleedAvoidance, box);
-        GraphicsContextStateSaver shadowStateSaver(*context, boxShadowShouldBeAppliedToBackground);
+        GraphicsContextStateSaver shadowStateSaver(context, boxShadowShouldBeAppliedToBackground);
         if (boxShadowShouldBeAppliedToBackground)
             BoxPainter::applyBoxShadowForBackground(context, obj);
 
         if (hasRoundedBorder && !bleedAvoidanceIsClipping(bleedAvoidance)) {
             FloatRoundedRect border = backgroundRoundedRectAdjustedForBleedAvoidance(obj, rect,
                 bleedAvoidance, box, boxSize, includeLeftEdge, includeRightEdge);
 
             if (border.isRenderable()) {
-                context->fillRoundedRect(border, bgColor);
+                context.fillRoundedRect(border, bgColor);
             } else {
                 RoundedInnerRectClipper clipper(obj, paintInfo, rect, border, ApplyToContext);
-                context->fillRect(border.rect(), bgColor);
+                context.fillRect(border.rect(), bgColor);
             }
         } else {
-            context->fillRect(pixelSnappedIntRect(rect), bgColor);
+            context.fillRect(pixelSnappedIntRect(rect), bgColor);
         }
 
         return;
     }
 
     // BorderFillBox radius clipping is taken care of by BackgroundBleedClip{Only,Layer}
     bool clipToBorderRadius = hasRoundedBorder && !(isBorderFill && bleedAvoidanceIsClipping(bleedAvoidance));
     Optional<RoundedInnerRectClipper> clipToBorder;
     if (clipToBorderRadius) {
         FloatRoundedRect border = isBorderFill
@@ skipping 14 matching lines @@
         }
 
         clipToBorder.emplace(obj, paintInfo, rect, border, ApplyToContext);
     }
 
     int bLeft = includeLeftEdge ? obj.borderLeft() : 0;
     int bRight = includeRightEdge ? obj.borderRight() : 0;
     LayoutUnit pLeft = includeLeftEdge ? obj.paddingLeft() : LayoutUnit();
     LayoutUnit pRight = includeRightEdge ? obj.paddingRight() : LayoutUnit();
 
-    GraphicsContextStateSaver clipWithScrollingStateSaver(*context, clippedWithLocalScrolling);
+    GraphicsContextStateSaver clipWithScrollingStateSaver(context, clippedWithLocalScrolling);
     LayoutRect scrolledPaintRect = rect;
     if (clippedWithLocalScrolling) {
         // Clip to the overflow area.
         const LayoutBox& thisBox = toLayoutBox(obj);
         // TODO(chrishtr): this should be pixel-snapped.
-        context->clip(FloatRect(thisBox.overflowClipRect(rect.location())));
+        context.clip(FloatRect(thisBox.overflowClipRect(rect.location())));
 
         // Adjust the paint rect to reflect a scrolled content box with borders at the ends.
         IntSize offset = thisBox.scrolledContentOffset();
         scrolledPaintRect.move(-offset);
         scrolledPaintRect.setWidth(bLeft + thisBox.scrollWidth() + bRight);
         scrolledPaintRect.setHeight(thisBox.borderTop() + thisBox.scrollHeight() + thisBox.borderBottom());
     }
 
-    GraphicsContextStateSaver backgroundClipStateSaver(*context, false);
+    GraphicsContextStateSaver backgroundClipStateSaver(context, false);
     IntRect maskRect;
 
     switch (bgLayer.clip()) {
     case PaddingFillBox:
     case ContentFillBox: {
         if (clipToBorderRadius)
             break;
 
         // Clip to the padding or content boxes as necessary.
         bool includePadding = bgLayer.clip() == ContentFillBox;
         LayoutRect clipRect(scrolledPaintRect.x() + bLeft + (includePadding ? pLeft : LayoutUnit()),
             scrolledPaintRect.y() + obj.borderTop() + (includePadding ? obj.paddingTop() : LayoutUnit()),
             scrolledPaintRect.width() - bLeft - bRight - (includePadding ? pLeft + pRight : LayoutUnit()),
             scrolledPaintRect.height() - obj.borderTop() - obj.borderBottom() - (includePadding ? obj.paddingTop() + obj.paddingBottom() : LayoutUnit()));
         backgroundClipStateSaver.save();
         // TODO(chrishtr): this should be pixel-snapped.
-        context->clip(FloatRect(clipRect));
+        context.clip(FloatRect(clipRect));
 
         break;
     }
     case TextFillBox: {
         // First figure out how big the mask has to be. It should be no bigger than what we need
         // to actually render, so we should intersect the dirty rect with the border box of the background.
         maskRect = pixelSnappedIntRect(rect);
 
         // We draw the background into a separate layer, to be later masked with yet another layer
         // holding the text content.
         backgroundClipStateSaver.save();
-        context->clip(maskRect);
-        context->beginLayer();
+        context.clip(maskRect);
+        context.beginLayer();
 
         break;
     }
     case BorderFillBox:
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 
     BackgroundImageGeometry geometry;
     if (bgImage)
         geometry.calculate(obj, paintInfo.paintContainer(), paintInfo.globalPaintFlags(), bgLayer, scrolledPaintRect);
     bool shouldPaintBackgroundImage = bgImage && bgImage->canRender();
 
     // Paint the color first underneath all images, culled if background image occludes it.
     // TODO(trchen): In the !bgLayer.hasRepeatXY() case, we could improve the culling test
     // by verifying whether the background image covers the entire painting area.
     if (isBottomLayer) {
         IntRect backgroundRect(pixelSnappedIntRect(scrolledPaintRect));
         bool boxShadowShouldBeAppliedToBackground = obj.boxShadowShouldBeAppliedToBackground(bleedAvoidance, box);
         bool backgroundImageOccludesBackgroundColor = shouldPaintBackgroundImage && isFillLayerOpaque(bgLayer, obj);
         if (boxShadowShouldBeAppliedToBackground || !backgroundImageOccludesBackgroundColor)  {
-            GraphicsContextStateSaver shadowStateSaver(*context, boxShadowShouldBeAppliedToBackground);
+            GraphicsContextStateSaver shadowStateSaver(context, boxShadowShouldBeAppliedToBackground);
             if (boxShadowShouldBeAppliedToBackground)
                 BoxPainter::applyBoxShadowForBackground(context, obj);
 
             if (bgColor.alpha())
-                context->fillRect(backgroundRect, bgColor);
+                context.fillRect(backgroundRect, bgColor);
         }
     }
 
     // no progressive loading of the background image
     if (shouldPaintBackgroundImage) {
         if (!geometry.destRect().isEmpty()) {
             SkXfermode::Mode bgOp = WebCoreCompositeToSkiaComposite(bgLayer.composite(), bgLayer.blendMode());
             // if op != SkXfermode::kSrcOver_Mode, a mask is being painted.
             SkXfermode::Mode compositeOp = op == SkXfermode::kSrcOver_Mode ? bgOp : op;
             const LayoutObject* clientForBackgroundImage = backgroundObject ? backgroundObject : &obj;
             RefPtr<Image> image = bgImage->image(clientForBackgroundImage, flooredIntSize(geometry.imageContainerSize()), obj.style()->effectiveZoom());
-            InterpolationQuality interpolationQuality = chooseInterpolationQuality(*clientForBackgroundImage, context, image.get(), &bgLayer, LayoutSize(geometry.tileSize()));
+            InterpolationQuality interpolationQuality = chooseInterpolationQuality(*clientForBackgroundImage, image.get(), &bgLayer, LayoutSize(geometry.tileSize()));
             if (bgLayer.maskSourceType() == MaskLuminance)
-                context->setColorFilter(ColorFilterLuminanceToAlpha);
-            InterpolationQuality previousInterpolationQuality = context->imageInterpolationQuality();
-            context->setImageInterpolationQuality(interpolationQuality);
+                context.setColorFilter(ColorFilterLuminanceToAlpha);
+            InterpolationQuality previousInterpolationQuality = context.imageInterpolationQuality();
+            context.setImageInterpolationQuality(interpolationQuality);
             TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data", InspectorPaintImageEvent::data(obj, *bgImage));
-            context->drawTiledImage(image.get(), FloatRect(geometry.destRect()), FloatPoint(geometry.phase()), FloatSize(geometry.tileSize()),
+            context.drawTiledImage(image.get(), FloatRect(geometry.destRect()), FloatPoint(geometry.phase()), FloatSize(geometry.tileSize()),
                 compositeOp, FloatSize(geometry.spaceSize()));
-            context->setImageInterpolationQuality(previousInterpolationQuality);
+            context.setImageInterpolationQuality(previousInterpolationQuality);
         }
     }
 
     if (bgLayer.clip() == TextFillBox) {
         // Create the text mask layer.
-        context->beginLayer(1, SkXfermode::kDstIn_Mode);
+        context.beginLayer(1, SkXfermode::kDstIn_Mode);
 
         // Now draw the text into the mask. We do this by painting using a special paint phase that signals to
         // InlineTextBoxes that they should just add their contents to the clip.
         PaintInfo info(context, maskRect, PaintPhaseTextClip, GlobalPaintNormalPhase, 0);
         if (box) {
             const RootInlineBox& root = box->root();
             box->paint(info, LayoutPoint(scrolledPaintRect.x() - box->x(), scrolledPaintRect.y() - box->y()), root.lineTop(), root.lineBottom());
         } else {
             // FIXME: this should only have an effect for the line box list within |obj|. Change this to create a LineBoxListPainter directly.
             LayoutSize localOffset = obj.isBox() ? toLayoutBox(&obj)->locationOffset() : LayoutSize();
             obj.paint(info, scrolledPaintRect.location() - localOffset);
         }
 
-        context->endLayer();
-        context->endLayer();
+        context.endLayer();
+        context.endLayer();
     }
 }
 
 void BoxPainter::paintMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (!paintInfo.shouldPaintWithinRoot(&m_layoutBox) || m_layoutBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
         return;
 
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutBox, paintInfo.phase, paintOffset))
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBox, paintInfo.phase, paintOffset))
         return;
 
     LayoutRect visualOverflowRect(m_layoutBox.visualOverflowRect());
     visualOverflowRect.moveBy(paintOffset);
 
-    LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutBox, paintInfo.phase, visualOverflowRect, paintOffset);
+    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutBox, paintInfo.phase, visualOverflowRect, paintOffset);
     LayoutRect paintRect = LayoutRect(paintOffset, m_layoutBox.size());
     paintMaskImages(paintInfo, paintRect);
 }
 
 void BoxPainter::paintMaskImages(const PaintInfo& paintInfo, const LayoutRect& paintRect)
 {
     // Figure out if we need to push a transparency layer to render our mask.
     bool pushTransparencyLayer = false;
     bool compositedMask = m_layoutBox.hasLayer() && m_layoutBox.layer()->hasCompositedMask();
     bool flattenCompositingLayers = paintInfo.globalPaintFlags() & GlobalPaintFlattenCompositingLayers;
 
     bool allMaskImagesLoaded = true;
 
     if (!compositedMask || flattenCompositingLayers) {
         pushTransparencyLayer = true;
         StyleImage* maskBoxImage = m_layoutBox.style()->maskBoxImage().image();
         const FillLayer& maskLayers = m_layoutBox.style()->maskLayers();
 
         // Don't render a masked element until all the mask images have loaded, to prevent a flash of unmasked content.
         if (maskBoxImage)
             allMaskImagesLoaded &= maskBoxImage->isLoaded();
 
         allMaskImagesLoaded &= maskLayers.imagesAreLoaded();
 
-        paintInfo.context->beginLayer(1, SkXfermode::kDstIn_Mode);
+        paintInfo.context.beginLayer(1, SkXfermode::kDstIn_Mode);
     }
 
     if (allMaskImagesLoaded) {
         paintFillLayers(paintInfo, Color::transparent, m_layoutBox.style()->maskLayers(), paintRect);
         paintNinePieceImage(m_layoutBox, paintInfo.context, paintRect, m_layoutBox.styleRef(), m_layoutBox.style()->maskBoxImage());
     }
 
     if (pushTransparencyLayer)
-        paintInfo.context->endLayer();
+        paintInfo.context.endLayer();
 }
 
 void BoxPainter::paintClippingMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ASSERT(paintInfo.phase == PaintPhaseClippingMask);
 
     if (!paintInfo.shouldPaintWithinRoot(&m_layoutBox) || m_layoutBox.style()->visibility() != VISIBLE)
         return;
 
     if (!m_layoutBox.layer() || m_layoutBox.layer()->compositingState() != PaintsIntoOwnBacking)
         return;
 
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutBox, paintInfo.phase, paintOffset))
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBox, paintInfo.phase, paintOffset))
         return;
 
     IntRect paintRect = pixelSnappedIntRect(LayoutRect(paintOffset, m_layoutBox.size()));
-    LayoutObjectDrawingRecorder drawingRecorder(*paintInfo.context, m_layoutBox, paintInfo.phase, paintRect, paintOffset);
-    paintInfo.context->fillRect(paintRect, Color::black);
+    LayoutObjectDrawingRecorder drawingRecorder(paintInfo.context, m_layoutBox, paintInfo.phase, paintRect, paintOffset);
+    paintInfo.context.fillRect(paintRect, Color::black);
 }
 
-InterpolationQuality BoxPainter::chooseInterpolationQuality(const LayoutObject& obj, GraphicsContext* context, Image* image, const void* layer, const LayoutSize& size)
+InterpolationQuality BoxPainter::chooseInterpolationQuality(const LayoutObject& obj, Image* image, const void* layer, const LayoutSize& size)
 {
-    return ImageQualityController::imageQualityController()->chooseInterpolationQuality(context, &obj, image, layer, size);
+    return ImageQualityController::imageQualityController()->chooseInterpolationQuality(obj, image, layer, size);
 }
 
-bool BoxPainter::paintNinePieceImage(const LayoutBoxModelObject& obj, GraphicsContext* graphicsContext, const LayoutRect& rect, const ComputedStyle& style, const NinePieceImage& ninePieceImage, SkXfermode::Mode op)
+bool BoxPainter::paintNinePieceImage(const LayoutBoxModelObject& obj, GraphicsContext& graphicsContext, const LayoutRect& rect, const ComputedStyle& style, const NinePieceImage& ninePieceImage, SkXfermode::Mode op)
 {
     NinePieceImagePainter ninePieceImagePainter(obj);
     return ninePieceImagePainter.paint(graphicsContext, rect, style, ninePieceImage, op);
 }
 
 void BoxPainter::paintBorder(const LayoutBoxModelObject& obj, const PaintInfo& info,
     const LayoutRect& rect, const ComputedStyle& style, BackgroundBleedAvoidance bleedAvoidance,
     bool includeLogicalLeftEdge, bool includeLogicalRightEdge)
 {
     // border-image is not affected by border-radius.
     if (paintNinePieceImage(obj, info.context, rect, style, style.borderImage()))
         return;
 
     const BoxBorderPainter borderPainter(rect, style, bleedAvoidance,
         includeLogicalLeftEdge, includeLogicalRightEdge);
     borderPainter.paintBorder(info, rect);
 }
 
 void BoxPainter::paintBoxShadow(const PaintInfo& info, const LayoutRect& paintRect, const ComputedStyle& style, ShadowStyle shadowStyle, bool includeLogicalLeftEdge, bool includeLogicalRightEdge)
 {
     // FIXME: Deal with border-image. Would be great to use border-image as a mask.
-    GraphicsContext* context = info.context;
+    GraphicsContext& context = info.context;
     if (!style.boxShadow())
         return;
     FloatRoundedRect border = (shadowStyle == Inset) ? style.getRoundedInnerBorderFor(paintRect, includeLogicalLeftEdge, includeLogicalRightEdge)
         : style.getRoundedBorderFor(paintRect, includeLogicalLeftEdge, includeLogicalRightEdge);
 
     bool hasBorderRadius = style.hasBorderRadius();
     bool isHorizontal = style.isHorizontalWritingMode();
     bool hasOpaqueBackground = style.visitedDependentColor(CSSPropertyBackgroundColor).alpha() == 255;
 
-    GraphicsContextStateSaver stateSaver(*context, false);
+    GraphicsContextStateSaver stateSaver(context, false);
 
     const ShadowList* shadowList = style.boxShadow();
     for (size_t i = shadowList->shadows().size(); i--; ) {
         const ShadowData& shadow = shadowList->shadows()[i];
         if (shadow.style() != shadowStyle)
             continue;
 
         FloatSize shadowOffset(shadow.x(), shadow.y());
         float shadowBlur = shadow.blur();
         float shadowSpread = shadow.spread();
@@ skipping 20 matching lines @@
                 if (hasBorderRadius) {
                     FloatRoundedRect rectToClipOut = border;
 
                     // If the box is opaque, it is unnecessary to clip it out. However, doing so saves time
                     // when painting the shadow. On the other hand, it introduces subpixel gaps along the
                     // corners. Those are avoided by insetting the clipping path by one CSS pixel.
                     if (hasOpaqueBackground)
                         rectToClipOut.inflateWithRadii(-1);
 
                     if (!rectToClipOut.isEmpty())
-                        context->clipOutRoundedRect(rectToClipOut);
+                        context.clipOutRoundedRect(rectToClipOut);
                 } else {
                     // This IntRect is correct even with fractional shadows, because it is used for the rectangle
                     // of the box itself, which is always pixel-aligned.
                     FloatRect rectToClipOut = border.rect();
 
                     // If the box is opaque, it is unnecessary to clip it out. However, doing so saves time
                     // when painting the shadow. On the other hand, it introduces subpixel gaps along the
                     // edges if they are not pixel-aligned. Those are avoided by insetting the clipping path
                     // by one CSS pixel.
                     if (hasOpaqueBackground)
                         rectToClipOut.inflate(-1);
 
                     if (!rectToClipOut.isEmpty())
-                        context->clipOut(rectToClipOut);
+                        context.clipOut(rectToClipOut);
                 }
             }
 
             // Draw only the shadow.
-            context->setShadow(shadowOffset, shadowBlur, shadowColor, DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha, DrawShadowOnly);
+            context.setShadow(shadowOffset, shadowBlur, shadowColor, DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha, DrawShadowOnly);
 
             if (hasBorderRadius) {
                 FloatRoundedRect influenceRect(pixelSnappedIntRect(LayoutRect(shadowRect)), border.radii());
                 float changeAmount = 2 * shadowBlur + shadowSpread;
                 if (changeAmount >= 0)
                     influenceRect.expandRadii(changeAmount);
                 else
                     influenceRect.shrinkRadii(-changeAmount);
 
                 FloatRoundedRect roundedFillRect = border;
                 roundedFillRect.inflate(shadowSpread);
 
                 if (shadowSpread >= 0)
                     roundedFillRect.expandRadii(shadowSpread);
                 else
                     roundedFillRect.shrinkRadii(-shadowSpread);
                 if (!roundedFillRect.isRenderable())
                     roundedFillRect.adjustRadii();
                 roundedFillRect.constrainRadii();
-                context->fillRoundedRect(roundedFillRect, Color::black);
+                context.fillRoundedRect(roundedFillRect, Color::black);
             } else {
-                context->fillRect(fillRect, Color::black);
+                context.fillRect(fillRect, Color::black);
             }
         } else {
             // The inset shadow case.
             GraphicsContext::Edges clippedEdges = GraphicsContext::NoEdge;
             if (!includeLogicalLeftEdge) {
                 if (isHorizontal)
                     clippedEdges |= GraphicsContext::LeftEdge;
                 else
                     clippedEdges |= GraphicsContext::TopEdge;
             }
             if (!includeLogicalRightEdge) {
                 if (isHorizontal)
                     clippedEdges |= GraphicsContext::RightEdge;
                 else
                     clippedEdges |= GraphicsContext::BottomEdge;
             }
-            context->drawInnerShadow(border, shadowColor, shadowOffset, shadowBlur, shadowSpread, clippedEdges);
+            context.drawInnerShadow(border, shadowColor, shadowOffset, shadowBlur, shadowSpread, clippedEdges);
         }
     }
 }
 
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(const ComputedStyle& style, const Document& document)
 {
     return document.printing() && style.printColorAdjust() == PrintColorAdjustEconomy
         && (!document.settings() || !document.settings()->shouldPrintBackgrounds());
 }
 
 } // namespace blink