Use refs for GraphicsContext

third_party/WebKit/Source/core/paint/BoxBorderPainter.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/BoxBorderPainter.h"
 
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/style/BorderEdge.h"
@@ skipping 233 matching lines @@
 LayoutRectOutsets doubleStripeInsets(const BorderEdge edges[], BorderEdge::DoubleBorderStripe stripe)
 {
     // Insets are representes as negative outsets.
     return LayoutRectOutsets(
         -edges[BSTop].getDoubleBorderStripeWidth(stripe),
         -edges[BSRight].getDoubleBorderStripeWidth(stripe),
         -edges[BSBottom].getDoubleBorderStripeWidth(stripe),
         -edges[BSLeft].getDoubleBorderStripeWidth(stripe));
 }
 
-void drawSolidBorderRect(GraphicsContext* context, const FloatRect& borderRect,
+void drawSolidBorderRect(GraphicsContext& context, const FloatRect& borderRect,
     float borderWidth, const Color& color)
 {
     FloatRect strokeRect(borderRect);
     strokeRect.inflate(-borderWidth / 2);
 
-    bool wasAntialias = context->shouldAntialias();
+    bool wasAntialias = context.shouldAntialias();
     if (!wasAntialias)
-        context->setShouldAntialias(true);
+        context.setShouldAntialias(true);
 
-    context->setStrokeStyle(SolidStroke);
-    context->setStrokeColor(color);
-    context->strokeRect(strokeRect, borderWidth);
+    context.setStrokeStyle(SolidStroke);
+    context.setStrokeColor(color);
+    context.strokeRect(strokeRect, borderWidth);
 
     if (!wasAntialias)
-        context->setShouldAntialias(false);
+        context.setShouldAntialias(false);
 }
 
-void drawBleedAdjustedDRRect(GraphicsContext* context, BackgroundBleedAvoidance bleedAvoidance,
+void drawBleedAdjustedDRRect(GraphicsContext& context, BackgroundBleedAvoidance bleedAvoidance,
     const FloatRoundedRect& outer, const FloatRoundedRect& inner, Color color)
 {
     switch (bleedAvoidance) {
     case BackgroundBleedClipLayer: {
         // BackgroundBleedClipLayer clips the outer rrect for the whole layer. Based on this,
         // we can avoid background bleeding by filling the *outside* of inner rrect, all the
         // way to the layer bounds (enclosing int rect for the clip, in device space).
         ASSERT(outer.isRounded());
 
         SkPath path;
         path.addRRect(inner);
         path.setFillType(SkPath::kInverseWinding_FillType);
 
         SkPaint paint;
         paint.setColor(color.rgb());
         paint.setStyle(SkPaint::kFill_Style);
         paint.setAntiAlias(true);
-        context->drawPath(path, paint);
+        context.drawPath(path, paint);
 
         break;
     }
     case BackgroundBleedClipOnly:
         if (outer.isRounded()) {
             // BackgroundBleedClipOnly clips the outer rrect corners for us.
             FloatRoundedRect adjustedOuter = outer;
             adjustedOuter.setRadii(FloatRoundedRect::Radii());
-            context->fillDRRect(adjustedOuter, inner, color);
+            context.fillDRRect(adjustedOuter, inner, color);
             break;
         }
         // fall through
     default:
-        context->fillDRRect(outer, inner, color);
+        context.fillDRRect(outer, inner, color);
         break;
     }
 }
 
 bool bleedAvoidanceIsClipping(BackgroundBleedAvoidance bleedAvoidance)
 {
     return bleedAvoidance == BackgroundBleedClipOnly || bleedAvoidance == BackgroundBleedClipLayer;
 }
 
 // The LUTs below assume specific enum values.
@@ skipping 117 matching lines @@
             ASSERT(!opacityGroups.isEmpty());
             OpacityGroup& currentGroup = opacityGroups.last();
             currentGroup.sides.append(side);
             currentGroup.edgeFlags |= edgeFlagForSide(side);
         }
 
         ASSERT(!opacityGroups.isEmpty());
     }
 };
 
-void BoxBorderPainter::drawDoubleBorder(GraphicsContext* context, const LayoutRect& borderRect) const
+void BoxBorderPainter::drawDoubleBorder(GraphicsContext& context, const LayoutRect& borderRect) const
 {
     ASSERT(m_isUniformColor);
     ASSERT(m_isUniformStyle);
     ASSERT(firstEdge().borderStyle() == DOUBLE);
     ASSERT(m_visibleEdgeSet == AllBorderEdges);
 
     const Color color = firstEdge().color;
 
     // outer stripe
     const LayoutRectOutsets outerThirdInsets =
         doubleStripeInsets(m_edges, BorderEdge::DoubleBorderStripeOuter);
     const FloatRoundedRect outerThirdRect = m_style.getRoundedInnerBorderFor(borderRect,
         outerThirdInsets, m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
     drawBleedAdjustedDRRect(context, m_bleedAvoidance, m_outer, outerThirdRect, color);
 
     // inner stripe
     const LayoutRectOutsets innerThirdInsets =
         doubleStripeInsets(m_edges, BorderEdge::DoubleBorderStripeInner);
     const FloatRoundedRect innerThirdRect = m_style.getRoundedInnerBorderFor(borderRect,
         innerThirdInsets, m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
-    context->fillDRRect(innerThirdRect, m_inner, color);
+    context.fillDRRect(innerThirdRect, m_inner, color);
 }
 
-bool BoxBorderPainter::paintBorderFastPath(GraphicsContext* context, const LayoutRect& borderRect) const
+bool BoxBorderPainter::paintBorderFastPath(GraphicsContext& context, const LayoutRect& borderRect) const
 {
     if (!m_isUniformColor || !m_isUniformStyle || !m_inner.isRenderable())
         return false;
 
     if (firstEdge().borderStyle() != SOLID && firstEdge().borderStyle() != DOUBLE)
         return false;
 
     if (m_visibleEdgeSet == AllBorderEdges) {
         if (firstEdge().borderStyle() == SOLID) {
             if (m_isUniformWidth && !m_outer.isRounded()) {
@@ skipping 19 matching lines @@
         // solid, rectangular border => one drawPath()
         Path path;
         path.setWindRule(RULE_NONZERO);
 
         for (int i = BSTop; i <= BSLeft; ++i) {
             const BorderEdge& currEdge = m_edges[i];
             if (currEdge.shouldRender())
                 path.addRect(calculateSideRect(m_outer, currEdge, i));
         }
 
-        context->setFillColor(firstEdge().color);
-        context->fillPath(path);
+        context.setFillColor(firstEdge().color);
+        context.fillPath(path);
         return true;
     }
 
     return false;
 }
 
 BoxBorderPainter::BoxBorderPainter(const LayoutRect& borderRect, const ComputedStyle& style,
     BackgroundBleedAvoidance bleedAvoidance, bool includeLogicalLeftEdge,
     bool includeLogicalRightEdge)
     : m_style(style)
@@ skipping 75 matching lines @@
         m_isUniformWidth &= edge.width == m_edges[m_firstVisibleEdge].width;
         m_isUniformColor &= edge.color == m_edges[m_firstVisibleEdge].color;
     }
 }
 
 void BoxBorderPainter::paintBorder(const PaintInfo& info, const LayoutRect& rect) const
 {
     if (!m_visibleEdgeCount || m_outer.rect().isEmpty())
         return;
 
-    GraphicsContext* graphicsContext = info.context;
+    GraphicsContext& graphicsContext = info.context;
 
     if (paintBorderFastPath(graphicsContext, rect))
         return;
 
     bool clipToOuterBorder = m_outer.isRounded();
-    GraphicsContextStateSaver stateSaver(*graphicsContext, clipToOuterBorder);
+    GraphicsContextStateSaver stateSaver(graphicsContext, clipToOuterBorder);
     if (clipToOuterBorder) {
         // For BackgroundBleedClip{Only,Layer}, the outer rrect clip is already applied.
         if (!bleedAvoidanceIsClipping(m_bleedAvoidance))
-            graphicsContext->clipRoundedRect(m_outer);
+            graphicsContext.clipRoundedRect(m_outer);
 
         if (m_inner.isRenderable() && !m_inner.isEmpty())
-            graphicsContext->clipOutRoundedRect(m_inner);
+            graphicsContext.clipOutRoundedRect(m_inner);
     }
 
     const ComplexBorderInfo borderInfo(*this, true);
     paintOpacityGroup(graphicsContext, borderInfo, 0, 1);
 }
 
 // In order to maximize the use of overdraw as a corner seam avoidance technique, we draw
 // translucent border sides using the following algorithm:
 //
 //   1) cluster sides sharing the same opacity into "opacity groups" [ComplexBorderInfo]
@@ skipping 28 matching lines @@
 //     beginLayer(0.5)             // layer for group 2 (effective opacity: 0.5 * 0.5 == 0.25)
 //       paintSides(right, left)   // paint group 2
 //     endLayer
 //     paintSides(bottom)          // paint group 1
 //   endLayer
 //   paintSides(top)               // paint group 0
 //
 // Note that we're always drawing using opaque paints on top of less-opaque content - hence
 // we can use overdraw to mask portions of the previous sides.
 //
-BorderEdgeFlags BoxBorderPainter::paintOpacityGroup(GraphicsContext* context,
+BorderEdgeFlags BoxBorderPainter::paintOpacityGroup(GraphicsContext& context,
     const ComplexBorderInfo& borderInfo, unsigned index, float effectiveOpacity) const
 {
     ASSERT(effectiveOpacity > 0 && effectiveOpacity <= 1);
 
     const size_t opacityGroupCount = borderInfo.opacityGroups.size();
 
     // For overdraw logic purposes, treat missing/transparent edges as completed.
     if (index >= opacityGroupCount)
         return ~m_visibleEdgeSet;
 
     // Groups are sorted in increasing opacity order, but we need to create layers in
     // decreasing opacity order - hence the reverse iteration.
     const OpacityGroup& group = borderInfo.opacityGroups[opacityGroupCount - index - 1];
 
     // Adjust this group's paint opacity to account for ancestor transparency layers
     // (needed in case we avoid creating a layer below).
     unsigned paintAlpha = group.alpha / effectiveOpacity;
     ASSERT(paintAlpha <= 255);
 
     // For the last (bottom) group, we can skip the layer even in the presence of opacity iff
     // it contains no adjecent edges (no in-group overdraw possibility).
     bool needsLayer = group.alpha != 255
         && (includesAdjacentEdges(group.edgeFlags) || (index + 1 < borderInfo.opacityGroups.size()));
 
     if (needsLayer) {
         const float groupOpacity = static_cast<float>(group.alpha) / 255;
         ASSERT(groupOpacity < effectiveOpacity);
 
-        context->beginLayer(groupOpacity / effectiveOpacity);
+        context.beginLayer(groupOpacity / effectiveOpacity);
         effectiveOpacity = groupOpacity;
 
         // Group opacity is applied via a layer => we draw the members using opaque paint.
         paintAlpha = 255;
     }
 
     // Recursion may seem unpalatable here, but
     //   a) it has an upper bound of 4
     //   b) only triggers at all when mixing border sides with different opacities
     //   c) it allows us to express the layer nesting algorithm more naturally
     BorderEdgeFlags completedEdges = paintOpacityGroup(context, borderInfo, index + 1, effectiveOpacity);
 
     // Paint the actual group edges with an alpha adjusted to account for ancenstor layers opacity.
     for (BoxSide side : group.sides) {
         paintSide(context, borderInfo, side, paintAlpha, completedEdges);
         completedEdges |= edgeFlagForSide(side);
     }
 
     if (needsLayer)
-        context->endLayer();
+        context.endLayer();
 
     return completedEdges;
 }
 
-void BoxBorderPainter::paintSide(GraphicsContext* context, const ComplexBorderInfo& borderInfo,
+void BoxBorderPainter::paintSide(GraphicsContext& context, const ComplexBorderInfo& borderInfo,
     BoxSide side, unsigned alpha, BorderEdgeFlags completedEdges) const
 {
     const BorderEdge& edge = m_edges[side];
     ASSERT(edge.shouldRender());
     const Color color(edge.color.red(), edge.color.green(), edge.color.blue(), alpha);
 
     FloatRect sideRect = m_outer.rect();
     const Path* path = nullptr;
 
     // TODO(fmalita): find a way to consolidate these without sacrificing readability.
@@ skipping 85 matching lines @@
         ? miter1 == HardMiter || miter2 == HardMiter
         : miter1 == SoftMiter || miter2 == SoftMiter;
 
     // Some styles require clipping for any type of miter.
     shouldClip = shouldClip
         || ((miter1 != NoMiter || miter2 != NoMiter) && styleRequiresClipPolygon(style));
 
     return shouldClip;
 }
 
-void BoxBorderPainter::paintOneBorderSide(GraphicsContext* graphicsContext,
+void BoxBorderPainter::paintOneBorderSide(GraphicsContext& graphicsContext,
     const FloatRect& sideRect, BoxSide side, BoxSide adjacentSide1, BoxSide adjacentSide2,
     const Path* path, bool antialias, Color color, BorderEdgeFlags completedEdges) const
 {
     const BorderEdge& edgeToRender = m_edges[side];
     ASSERT(edgeToRender.width);
     const BorderEdge& adjacentEdge1 = m_edges[adjacentSide1];
     const BorderEdge& adjacentEdge2 = m_edges[adjacentSide2];
 
     if (path) {
         MiterType miter1 = colorsMatchAtCorner(side, adjacentSide1, m_edges) ? HardMiter : SoftMiter;
         MiterType miter2 = colorsMatchAtCorner(side, adjacentSide2, m_edges) ? HardMiter : SoftMiter;
 
-        GraphicsContextStateSaver stateSaver(*graphicsContext);
+        GraphicsContextStateSaver stateSaver(graphicsContext);
         if (m_inner.isRenderable())
             clipBorderSidePolygon(graphicsContext, side, miter1, miter2);
         else
             clipBorderSideForComplexInnerPath(graphicsContext, side);
         float thickness = std::max(std::max(edgeToRender.width, adjacentEdge1.width), adjacentEdge2.width);
         drawBoxSideFromPath(graphicsContext, LayoutRect(m_outer.rect()), *path, edgeToRender.width,
             thickness, side, color, edgeToRender.borderStyle());
     } else {
         MiterType miter1 = computeMiter(side, adjacentSide1, completedEdges, antialias);
         MiterType miter2 = computeMiter(side, adjacentSide2, completedEdges, antialias);
         bool shouldClip = mitersRequireClipping(miter1, miter2, edgeToRender.borderStyle(), antialias);
 
-        GraphicsContextStateSaver clipStateSaver(*graphicsContext, shouldClip);
+        GraphicsContextStateSaver clipStateSaver(graphicsContext, shouldClip);
         if (shouldClip) {
             clipBorderSidePolygon(graphicsContext, side, miter1, miter2);
 
             // Miters are applied via clipping, no need to draw them.
             miter1 = miter2 = NoMiter;
         }
 
         ObjectPainter::drawLineForBoxSide(graphicsContext, sideRect.x(), sideRect.y(),
             sideRect.maxX(), sideRect.maxY(), side, color, edgeToRender.borderStyle(),
             miter1 != NoMiter ? adjacentEdge1.width : 0, miter2 != NoMiter ? adjacentEdge2.width : 0,
             antialias);
     }
 }
 
-void BoxBorderPainter::drawBoxSideFromPath(GraphicsContext* graphicsContext,
+void BoxBorderPainter::drawBoxSideFromPath(GraphicsContext& graphicsContext,
     const LayoutRect& borderRect, const Path& borderPath, float thickness, float drawThickness,
     BoxSide side, Color color, EBorderStyle borderStyle) const
 {
     if (thickness <= 0)
         return;
 
     if (borderStyle == DOUBLE && thickness < 3)
         borderStyle = SOLID;
 
     switch (borderStyle) {
     case BNONE:
     case BHIDDEN:
         return;
     case DOTTED:
     case DASHED: {
-        graphicsContext->setStrokeColor(color);
+        graphicsContext.setStrokeColor(color);
 
         // The stroke is doubled here because the provided path is the
         // outside edge of the border so half the stroke is clipped off.
         // The extra multiplier is so that the clipping mask can antialias
         // the edges to prevent jaggies.
-        graphicsContext->setStrokeThickness(drawThickness * 2 * 1.1f);
-        graphicsContext->setStrokeStyle(borderStyle == DASHED ? DashedStroke : DottedStroke);
+        graphicsContext.setStrokeThickness(drawThickness * 2 * 1.1f);
+        graphicsContext.setStrokeStyle(borderStyle == DASHED ? DashedStroke : DottedStroke);
 
         // If the number of dashes that fit in the path is odd and non-integral then we
         // will have an awkwardly-sized dash at the end of the path. To try to avoid that
         // here, we simply make the whitespace dashes ever so slightly bigger.
         // FIXME: This could be even better if we tried to manipulate the dash offset
         // and possibly the gapLength to get the corners dash-symmetrical.
         float dashLength = thickness * ((borderStyle == DASHED) ? 3.0f : 1.0f);
         float gapLength = dashLength;
         float numberOfDashes = borderPath.length() / dashLength;
         // Don't try to show dashes if we have less than 2 dashes + 2 gaps.
         // FIXME: should do this test per side.
         if (numberOfDashes >= 4) {
             bool evenNumberOfFullDashes = !((int)numberOfDashes % 2);
             bool integralNumberOfDashes = !(numberOfDashes - (int)numberOfDashes);
             if (!evenNumberOfFullDashes && !integralNumberOfDashes) {
                 float numberOfGaps = numberOfDashes / 2;
                 gapLength += (dashLength  / numberOfGaps);
             }
 
             DashArray lineDash;
             lineDash.append(dashLength);
             lineDash.append(gapLength);
-            graphicsContext->setLineDash(lineDash, dashLength);
+            graphicsContext.setLineDash(lineDash, dashLength);
         }
 
         // FIXME: stroking the border path causes issues with tight corners:
         // https://bugs.webkit.org/show_bug.cgi?id=58711
         // Also, to get the best appearance we should stroke a path between the two borders.
-        graphicsContext->strokePath(borderPath);
+        graphicsContext.strokePath(borderPath);
         return;
     }
     case DOUBLE: {
         // Draw inner border line
         {
-            GraphicsContextStateSaver stateSaver(*graphicsContext);
+            GraphicsContextStateSaver stateSaver(graphicsContext);
             const LayoutRectOutsets innerInsets = doubleStripeInsets(m_edges, BorderEdge::DoubleBorderStripeInner);
             FloatRoundedRect innerClip = m_style.getRoundedInnerBorderFor(borderRect, innerInsets,
                 m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
 
-            graphicsContext->clipRoundedRect(innerClip);
+            graphicsContext.clipRoundedRect(innerClip);
             drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness, drawThickness,
                 side, color, SOLID);
         }
 
         // Draw outer border line
         {
-            GraphicsContextStateSaver stateSaver(*graphicsContext);
+            GraphicsContextStateSaver stateSaver(graphicsContext);
             LayoutRect outerRect = borderRect;
             LayoutRectOutsets outerInsets = doubleStripeInsets(m_edges, BorderEdge::DoubleBorderStripeOuter);
 
             if (bleedAvoidanceIsClipping(m_bleedAvoidance)) {
                 outerRect.inflate(1);
                 outerInsets.setTop(outerInsets.top() - 1);
                 outerInsets.setRight(outerInsets.right() - 1);
                 outerInsets.setBottom(outerInsets.bottom() - 1);
                 outerInsets.setLeft(outerInsets.left() - 1);
             }
 
             FloatRoundedRect outerClip = m_style.getRoundedInnerBorderFor(outerRect, outerInsets,
                 m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
-            graphicsContext->clipOutRoundedRect(outerClip);
+            graphicsContext.clipOutRoundedRect(outerClip);
             drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness, drawThickness,
                 side, color, SOLID);
         }
         return;
     }
     case RIDGE:
     case GROOVE:
     {
         EBorderStyle s1;
         EBorderStyle s2;
         if (borderStyle == GROOVE) {
             s1 = INSET;
             s2 = OUTSET;
         } else {
             s1 = OUTSET;
             s2 = INSET;
         }
 
         // Paint full border
         drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness, drawThickness,
             side, color, s1);
 
         // Paint inner only
-        GraphicsContextStateSaver stateSaver(*graphicsContext);
+        GraphicsContextStateSaver stateSaver(graphicsContext);
         LayoutUnit topWidth = m_edges[BSTop].usedWidth() / 2;
         LayoutUnit bottomWidth = m_edges[BSBottom].usedWidth() / 2;
         LayoutUnit leftWidth = m_edges[BSLeft].usedWidth() / 2;
         LayoutUnit rightWidth = m_edges[BSRight].usedWidth() / 2;
 
         FloatRoundedRect clipRect = m_style.getRoundedInnerBorderFor(borderRect,
             LayoutRectOutsets(-topWidth, -rightWidth, -bottomWidth, -leftWidth),
             m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
 
-        graphicsContext->clipRoundedRect(clipRect);
+        graphicsContext.clipRoundedRect(clipRect);
         drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness, drawThickness,
             side, color, s2);
         return;
     }
     case INSET:
         if (side == BSTop || side == BSLeft)
             color = color.dark();
         break;
     case OUTSET:
         if (side == BSBottom || side == BSRight)
             color = color.dark();
         break;
     default:
         break;
     }
 
-    graphicsContext->setStrokeStyle(NoStroke);
-    graphicsContext->setFillColor(color);
-    graphicsContext->drawRect(pixelSnappedIntRect(borderRect));
+    graphicsContext.setStrokeStyle(NoStroke);
+    graphicsContext.setFillColor(color);
+    graphicsContext.drawRect(pixelSnappedIntRect(borderRect));
 }
 
-void BoxBorderPainter::clipBorderSideForComplexInnerPath(GraphicsContext* graphicsContext,
+void BoxBorderPainter::clipBorderSideForComplexInnerPath(GraphicsContext& graphicsContext,
     BoxSide side) const
 {
-    graphicsContext->clip(calculateSideRectIncludingInner(m_outer, m_edges, side));
+    graphicsContext.clip(calculateSideRectIncludingInner(m_outer, m_edges, side));
     FloatRoundedRect adjustedInnerRect = calculateAdjustedInnerBorder(m_inner, side);
     if (!adjustedInnerRect.isEmpty())
-        graphicsContext->clipOutRoundedRect(adjustedInnerRect);
+        graphicsContext.clipOutRoundedRect(adjustedInnerRect);
 }
 
-void BoxBorderPainter::clipBorderSidePolygon(GraphicsContext* graphicsContext, BoxSide side,
+void BoxBorderPainter::clipBorderSidePolygon(GraphicsContext& graphicsContext, BoxSide side,
     MiterType firstMiter, MiterType secondMiter) const
 {
     ASSERT(firstMiter != NoMiter || secondMiter != NoMiter);
 
     FloatPoint quad[4];
 
     const LayoutRect outerRect(m_outer.rect());
     const LayoutRect innerRect(m_inner.rect());
 
     // For each side, create a quad that encompasses all parts of that side that may draw,
@@ skipping 122 matching lines @@
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
                     quad[2].y() - m_inner.radii().bottomRight().height()),
                 quad[2]);
         }
         break;
     }
 
     if (firstMiter == secondMiter) {
-        graphicsContext->clipPolygon(4, quad, firstMiter == SoftMiter);
+        graphicsContext.clipPolygon(4, quad, firstMiter == SoftMiter);
         return;
     }
 
     // If antialiasing settings for the first edge and second edge is different,
     // they have to be addressed separately. We do this by breaking the quad into
     // two parallelograms, made by moving quad[1] and quad[2].
     float ax = quad[1].x() - quad[0].x();
     float ay = quad[1].y() - quad[0].y();
     float bx = quad[2].x() - quad[1].x();
     float by = quad[2].y() - quad[1].y();
@@ skipping 12 matching lines @@
         r1 = (-ax * by + ay * bx) / (cx * by - cy * bx) + kExtendFill;
         r2 = (-cx * by + cy * bx) / (ax * by - ay * bx) + kExtendFill;
     }
 
     if (firstMiter != NoMiter) {
         FloatPoint firstQuad[4];
         firstQuad[0] = quad[0];
         firstQuad[1] = quad[1];
         firstQuad[2] = FloatPoint(quad[3].x() + r2 * ax, quad[3].y() + r2 * ay);
         firstQuad[3] = quad[3];
-        graphicsContext->clipPolygon(4, firstQuad, firstMiter == SoftMiter);
+        graphicsContext.clipPolygon(4, firstQuad, firstMiter == SoftMiter);
     }
 
     if (secondMiter != NoMiter) {
         FloatPoint secondQuad[4];
         secondQuad[0] = quad[0];
         secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
         secondQuad[2] = quad[2];
         secondQuad[3] = quad[3];
-        graphicsContext->clipPolygon(4, secondQuad, secondMiter == SoftMiter);
+        graphicsContext.clipPolygon(4, secondQuad, secondMiter == SoftMiter);
     }
 }
 
 } // namespace blink