Use refs for GraphicsContext

third_party/WebKit/Source/core/paint/ObjectPainter.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/ObjectPainter.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 159 matching lines @@
     // The width of the angled part of starting and ending joint of the current edge.
     int adjacentWidthStart = firstAdjacentWidth;
     int adjacentWidthEnd;
     for (size_t i = 0; i < count; ++i) {
         OutlineEdgeInfo& edge = edges[i];
         adjacentWidthEnd = i == count - 1 ? firstAdjacentWidth : adjustJoint(width, edge, edges[i + 1]);
         int adjacentWidth1 = adjacentWidthStart;
         int adjacentWidth2 = adjacentWidthEnd;
         if (edge.side == BSLeft || edge.side == BSBottom)
             std::swap(adjacentWidth1, adjacentWidth2);
-        ObjectPainter::drawLineForBoxSide(&graphicsContext, edge.x1, edge.y1, edge.x2, edge.y2, edge.side, outlineColor, style.outlineStyle(), adjacentWidth1, adjacentWidth2, false);
+        ObjectPainter::drawLineForBoxSide(graphicsContext, edge.x1, edge.y1, edge.x2, edge.y2, edge.side, outlineColor, style.outlineStyle(), adjacentWidth1, adjacentWidth2, false);
         adjacentWidthStart = adjacentWidthEnd;
     }
 
     if (useTransparencyLayer)
         graphicsContext.endLayer();
 }
 
 } // namespace
 
 void ObjectPainter::paintOutline(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ASSERT(paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline);
 
     const ComputedStyle& styleToUse = m_layoutObject.styleRef();
     if (!styleToUse.hasOutline() || styleToUse.visibility() != VISIBLE)
         return;
 
     // Only paint the focus ring by hand if the theme isn't able to draw the focus ring.
     if (styleToUse.outlineStyleIsAuto() && !LayoutTheme::theme().shouldDrawDefaultFocusRing(m_layoutObject))
         return;
 
     Vector<LayoutRect> outlineRects;
     m_layoutObject.addOutlineRects(outlineRects, paintOffset, m_layoutObject.outlineRectsShouldIncludeBlockVisualOverflow());
     if (outlineRects.isEmpty())
         return;
 
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutObject, paintInfo.phase, paintOffset))
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutObject, paintInfo.phase, paintOffset))
         return;
 
     // The result rects are in coordinates of m_layoutObject's border box.
     // Block flipping is not applied yet if !m_layoutObject.isBox().
     if (!m_layoutObject.isBox() && m_layoutObject.styleRef().isFlippedBlocksWritingMode()) {
         LayoutBlock* container = m_layoutObject.containingBlock();
         if (container) {
             m_layoutObject.localToContainerRects(outlineRects, container, -paintOffset, paintOffset);
             if (outlineRects.isEmpty())
                 return;
         }
     }
 
     Vector<IntRect> pixelSnappedOutlineRects;
     for (auto& r : outlineRects)
         pixelSnappedOutlineRects.append(pixelSnappedIntRect(r));
 
     IntRect unitedOutlineRect = unionRectEvenIfEmpty(pixelSnappedOutlineRects);
     IntRect bounds = unitedOutlineRect;
     bounds.inflate(m_layoutObject.styleRef().outlineOutsetExtent());
-    LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutObject, paintInfo.phase, bounds, paintOffset);
+    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutObject, paintInfo.phase, bounds, paintOffset);
 
     Color color = m_layoutObject.resolveColor(styleToUse, CSSPropertyOutlineColor);
     if (styleToUse.outlineStyleIsAuto()) {
-        paintInfo.context->drawFocusRing(pixelSnappedOutlineRects, styleToUse.outlineWidth(), styleToUse.outlineOffset(), color);
+        paintInfo.context.drawFocusRing(pixelSnappedOutlineRects, styleToUse.outlineWidth(), styleToUse.outlineOffset(), color);
         return;
     }
 
     if (unitedOutlineRect == pixelSnappedOutlineRects[0]) {
         paintSingleRectangleOutline(paintInfo, unitedOutlineRect, styleToUse, color);
         return;
     }
-    paintComplexOutline(*paintInfo.context, pixelSnappedOutlineRects, styleToUse, color);
+    paintComplexOutline(paintInfo.context, pixelSnappedOutlineRects, styleToUse, color);
 }
 
 void ObjectPainter::paintInlineChildrenOutlines(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ASSERT(paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseChildOutlines);
 
     PaintInfo childPaintInfo(paintInfo);
     childPaintInfo.phase = paintInfo.phase == PaintPhaseChildOutlines ? PaintPhaseOutline : paintInfo.phase;
 
     for (LayoutObject* child = m_layoutObject.slowFirstChild(); child; child = child->nextSibling()) {
@@ skipping 11 matching lines @@
     KURL url = toElement(m_layoutObject.node())->hrefURL();
     if (!url.isValid())
         return;
 
     Vector<LayoutRect> visualOverflowRects;
     m_layoutObject.addElementVisualOverflowRects(visualOverflowRects, paintOffset);
     IntRect rect = pixelSnappedIntRect(unionRect(visualOverflowRects));
     if (rect.isEmpty())
         return;
 
-    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutObject, DisplayItem::PrintedContentPDFURLRect, paintOffset))
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutObject, DisplayItem::PrintedContentPDFURLRect, paintOffset))
         return;
 
-    LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutObject, DisplayItem::PrintedContentPDFURLRect, rect, paintOffset);
+    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutObject, DisplayItem::PrintedContentPDFURLRect, rect, paintOffset);
     if (url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(url, m_layoutObject.document().baseURL())) {
         String fragmentName = url.fragmentIdentifier();
         if (m_layoutObject.document().findAnchor(fragmentName))
-            paintInfo.context->setURLFragmentForRect(fragmentName, rect);
+            paintInfo.context.setURLFragmentForRect(fragmentName, rect);
         return;
     }
-    paintInfo.context->setURLForRect(url, rect);
+    paintInfo.context.setURLForRect(url, rect);
 }
 
-void ObjectPainter::drawLineForBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
+void ObjectPainter::drawLineForBoxSide(GraphicsContext& graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, EBorderStyle style,
     int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     int thickness;
     int length;
     if (side == BSTop || side == BSBottom) {
         thickness = y2 - y1;
         length = x2 - x1;
     } else {
         thickness = x2 - x1;
@@ skipping 35 matching lines @@
     case OUTSET:
         if (style == OUTSET && (side == BSBottom || side == BSRight))
             color = color.dark();
         // fall through
     case SOLID:
         drawSolidBoxSide(graphicsContext, x1, y1, x2, y2, side, color, adjacentWidth1, adjacentWidth2, antialias);
         break;
     }
 }
 
-void ObjectPainter::drawDashedOrDottedBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
+void ObjectPainter::drawDashedOrDottedBoxSide(GraphicsContext& graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, int thickness, EBorderStyle style, bool antialias)
 {
     if (thickness <= 0)
         return;
 
-    bool wasAntialiased = graphicsContext->shouldAntialias();
-    StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
-    graphicsContext->setShouldAntialias(antialias);
-    graphicsContext->setStrokeColor(color);
-    graphicsContext->setStrokeThickness(thickness);
-    graphicsContext->setStrokeStyle(style == DASHED ? DashedStroke : DottedStroke);
+    bool wasAntialiased = graphicsContext.shouldAntialias();
+    StrokeStyle oldStrokeStyle = graphicsContext.strokeStyle();
+    graphicsContext.setShouldAntialias(antialias);
+    graphicsContext.setStrokeColor(color);
+    graphicsContext.setStrokeThickness(thickness);
+    graphicsContext.setStrokeStyle(style == DASHED ? DashedStroke : DottedStroke);
 
     switch (side) {
     case BSBottom:
     case BSTop: {
         int midY = y1 + thickness / 2;
-        graphicsContext->drawLine(IntPoint(x1, midY), IntPoint(x2, midY));
+        graphicsContext.drawLine(IntPoint(x1, midY), IntPoint(x2, midY));
         break;
     }
     case BSRight:
     case BSLeft: {
         int midX = x1 + thickness / 2;
-        graphicsContext->drawLine(IntPoint(midX, y1), IntPoint(midX, y2));
+        graphicsContext.drawLine(IntPoint(midX, y1), IntPoint(midX, y2));
         break;
     }
     }
-    graphicsContext->setShouldAntialias(wasAntialiased);
-    graphicsContext->setStrokeStyle(oldStrokeStyle);
+    graphicsContext.setShouldAntialias(wasAntialiased);
+    graphicsContext.setStrokeStyle(oldStrokeStyle);
 }
 
-void ObjectPainter::drawDoubleBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
+void ObjectPainter::drawDoubleBoxSide(GraphicsContext& graphicsContext, int x1, int y1, int x2, int y2,
     int length, BoxSide side, Color color, int thickness, int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     int thirdOfThickness = (thickness + 1) / 3;
     ASSERT(thirdOfThickness);
 
     if (!adjacentWidth1 && !adjacentWidth2) {
-        StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
-        graphicsContext->setStrokeStyle(NoStroke);
-        graphicsContext->setFillColor(color);
+        StrokeStyle oldStrokeStyle = graphicsContext.strokeStyle();
+        graphicsContext.setStrokeStyle(NoStroke);
+        graphicsContext.setFillColor(color);
 
-        bool wasAntialiased = graphicsContext->shouldAntialias();
-        graphicsContext->setShouldAntialias(antialias);
+        bool wasAntialiased = graphicsContext.shouldAntialias();
+        graphicsContext.setShouldAntialias(antialias);
 
         switch (side) {
         case BSTop:
         case BSBottom:
-            graphicsContext->drawRect(IntRect(x1, y1, length, thirdOfThickness));
-            graphicsContext->drawRect(IntRect(x1, y2 - thirdOfThickness, length, thirdOfThickness));
+            graphicsContext.drawRect(IntRect(x1, y1, length, thirdOfThickness));
+            graphicsContext.drawRect(IntRect(x1, y2 - thirdOfThickness, length, thirdOfThickness));
             break;
         case BSLeft:
         case BSRight:
-            graphicsContext->drawRect(IntRect(x1, y1, thirdOfThickness, length));
-            graphicsContext->drawRect(IntRect(x2 - thirdOfThickness, y1, thirdOfThickness, length));
+            graphicsContext.drawRect(IntRect(x1, y1, thirdOfThickness, length));
+            graphicsContext.drawRect(IntRect(x2 - thirdOfThickness, y1, thirdOfThickness, length));
             break;
         }
 
-        graphicsContext->setShouldAntialias(wasAntialiased);
-        graphicsContext->setStrokeStyle(oldStrokeStyle);
+        graphicsContext.setShouldAntialias(wasAntialiased);
+        graphicsContext.setStrokeStyle(oldStrokeStyle);
         return;
     }
 
     int adjacent1BigThird = ((adjacentWidth1 > 0) ? adjacentWidth1 + 1 : adjacentWidth1 - 1) / 3;
     int adjacent2BigThird = ((adjacentWidth2 > 0) ? adjacentWidth2 + 1 : adjacentWidth2 - 1) / 3;
 
     switch (side) {
     case BSTop:
         drawLineForBoxSide(graphicsContext, x1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
             y1, x2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
@@ skipping 24 matching lines @@
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
             x2, y2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0),
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         break;
     default:
         break;
     }
 }
 
-void ObjectPainter::drawRidgeOrGrooveBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
+void ObjectPainter::drawRidgeOrGrooveBoxSide(GraphicsContext& graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, EBorderStyle style, int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     EBorderStyle s1;
     EBorderStyle s2;
     if (style == GROOVE) {
         s1 = INSET;
         s2 = OUTSET;
     } else {
         s1 = OUTSET;
         s2 = INSET;
@@ skipping 23 matching lines @@
         break;
     case BSRight:
         drawLineForBoxSide(graphicsContext, x1, y1 + std::max(adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - std::max(adjacentWidth2, 0) / 2,
             side, color, s2, adjacent1BigHalf, adjacent2BigHalf, antialias);
         drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + std::max(-adjacentWidth1 + 1, 0) / 2, x2, y2 - std::max(-adjacentWidth2 + 1, 0) / 2,
             side, color, s1, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
         break;
     }
 }
 
-void ObjectPainter::drawSolidBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
+void ObjectPainter::drawSolidBoxSide(GraphicsContext& graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     ASSERT(x2 >= x1);
     ASSERT(y2 >= y1);
 
     if (!adjacentWidth1 && !adjacentWidth2) {
         // Tweak antialiasing to match the behavior of fillPolygon();
         // this matters for rects in transformed contexts.
-        bool wasAntialiased = graphicsContext->shouldAntialias();
+        bool wasAntialiased = graphicsContext.shouldAntialias();
         if (antialias != wasAntialiased)
-            graphicsContext->setShouldAntialias(antialias);
-        graphicsContext->fillRect(IntRect(x1, y1, x2 - x1, y2 - y1), color);
+            graphicsContext.setShouldAntialias(antialias);
+        graphicsContext.fillRect(IntRect(x1, y1, x2 - x1, y2 - y1), color);
         if (antialias != wasAntialiased)
-            graphicsContext->setShouldAntialias(wasAntialiased);
+            graphicsContext.setShouldAntialias(wasAntialiased);
         return;
     }
 
     FloatPoint quad[4];
     switch (side) {
     case BSTop:
         quad[0] = FloatPoint(x1 + std::max(-adjacentWidth1, 0), y1);
         quad[1] = FloatPoint(x1 + std::max(adjacentWidth1, 0), y2);
         quad[2] = FloatPoint(x2 - std::max(adjacentWidth2, 0), y2);
         quad[3] = FloatPoint(x2 - std::max(-adjacentWidth2, 0), y1);
@@ skipping 11 matching lines @@
         quad[3] = FloatPoint(x2, y1 + std::max(adjacentWidth1, 0));
         break;
     case BSRight:
         quad[0] = FloatPoint(x1, y1 + std::max(adjacentWidth1, 0));
         quad[1] = FloatPoint(x1, y2 - std::max(adjacentWidth2, 0));
         quad[2] = FloatPoint(x2, y2 - std::max(-adjacentWidth2, 0));
         quad[3] = FloatPoint(x2, y1 + std::max(-adjacentWidth1, 0));
         break;
     }
 
-    graphicsContext->fillPolygon(4, quad, color, antialias);
+    graphicsContext.fillPolygon(4, quad, color, antialias);
 }
 
 } // namespace blink