Use refs for GraphicsContext

third_party/WebKit/Source/platform/graphics/Image.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 78 matching lines @@
     if (!m_encodedImageData.get())
         return true;
 
     int length = m_encodedImageData->size();
     if (!length)
         return true;
 
     return dataChanged(allDataReceived);
 }
 
-void Image::drawTiled(GraphicsContext* ctxt, const FloatRect& destRect, const FloatPoint& srcPoint, const FloatSize& scaledTileSize, SkXfermode::Mode op, const FloatSize& repeatSpacing)
+void Image::drawTiled(GraphicsContext& ctxt, const FloatRect& destRect, const FloatPoint& srcPoint, const FloatSize& scaledTileSize, SkXfermode::Mode op, const FloatSize& repeatSpacing)
 {
     FloatSize intrinsicTileSize = FloatSize(size());
     if (hasRelativeWidth())
         intrinsicTileSize.setWidth(scaledTileSize.width());
     if (hasRelativeHeight())
         intrinsicTileSize.setHeight(scaledTileSize.height());
 
     FloatSize scale(scaledTileSize.width() / intrinsicTileSize.width(),
                     scaledTileSize.height() / intrinsicTileSize.height());
 
     FloatSize actualTileSize(scaledTileSize.width() + repeatSpacing.width(), scaledTileSize.height() + repeatSpacing.height());
     FloatRect oneTileRect;
     oneTileRect.setX(destRect.x() + fmodf(fmodf(-srcPoint.x(), actualTileSize.width()) - actualTileSize.width(), actualTileSize.width()));
     oneTileRect.setY(destRect.y() + fmodf(fmodf(-srcPoint.y(), actualTileSize.height()) - actualTileSize.height(), actualTileSize.height()));
     oneTileRect.setSize(scaledTileSize);
 
     // Check and see if a single draw of the image can cover the entire area we are supposed to tile.
     if (oneTileRect.contains(destRect)) {
         FloatRect visibleSrcRect;
         visibleSrcRect.setX((destRect.x() - oneTileRect.x()) / scale.width());
         visibleSrcRect.setY((destRect.y() - oneTileRect.y()) / scale.height());
         visibleSrcRect.setWidth(destRect.width() / scale.width());
         visibleSrcRect.setHeight(destRect.height() / scale.height());
-        ctxt->drawImage(this, destRect, visibleSrcRect, op, DoNotRespectImageOrientation);
+        ctxt.drawImage(this, destRect, visibleSrcRect, op, DoNotRespectImageOrientation);
         return;
     }
 
     FloatRect tileRect(FloatPoint(), intrinsicTileSize);
     drawPattern(ctxt, tileRect, scale, oneTileRect.location(), op, destRect, repeatSpacing);
 
     startAnimation();
 }
 
 // FIXME: Merge with the other drawTiled eventually, since we need a combination of both for some things.
-void Image::drawTiled(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect,
+void Image::drawTiled(GraphicsContext& ctxt, const FloatRect& dstRect, const FloatRect& srcRect,
     const FloatSize& providedTileScaleFactor, TileRule hRule, TileRule vRule, SkXfermode::Mode op)
 {
     // FIXME: We do not support 'space' yet. For now just map it to 'repeat'.
     if (hRule == SpaceTile)
         hRule = RepeatTile;
     if (vRule == SpaceTile)
         vRule = RepeatTile;
 
     // FIXME: if this code is used for background-repeat: round (in addition to
     // border-image-repeat), then add logic to deal with the background-size: auto
@@ skipping 21 matching lines @@
     float vPhase = tileScaleFactor.height() * srcRect.y();
     float scaledTileWidth = tileScaleFactor.width() * srcRect.width();
     float scaledTileHeight = tileScaleFactor.height() * srcRect.height();
     if (hRule == Image::RepeatTile)
         hPhase -= (dstRect.width() - scaledTileWidth) / 2;
     if (vRule == Image::RepeatTile)
         vPhase -= (dstRect.height() - scaledTileHeight) / 2;
     FloatPoint patternPhase(dstRect.x() - hPhase, dstRect.y() - vPhase);
 
     if (useLowInterpolationQuality) {
-        InterpolationQuality previousInterpolationQuality = ctxt->imageInterpolationQuality();
-        ctxt->setImageInterpolationQuality(InterpolationLow);
+        InterpolationQuality previousInterpolationQuality = ctxt.imageInterpolationQuality();
+        ctxt.setImageInterpolationQuality(InterpolationLow);
         drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, op, dstRect);
-        ctxt->setImageInterpolationQuality(previousInterpolationQuality);
+        ctxt.setImageInterpolationQuality(previousInterpolationQuality);
     } else {
         drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, op, dstRect);
     }
 
     startAnimation();
 }
 
 namespace {
 
 PassRefPtr<SkShader> createPatternShader(const SkImage* image, const SkMatrix& shaderMatrix,
@@ skipping 12 matching lines @@
     SkCanvas* canvas = recorder.beginRecording(tileRect);
     canvas->drawImage(image, 0, 0, &paint);
     RefPtr<const SkPicture> picture = adoptRef(recorder.endRecordingAsPicture());
 
     return adoptRef(SkShader::CreatePictureShader(
         picture.get(), SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &shaderMatrix, nullptr));
 }
 
 } // anonymous namespace
 
-void Image::drawPattern(GraphicsContext* context, const FloatRect& floatSrcRect, const FloatSize& scale,
+void Image::drawPattern(GraphicsContext& context, const FloatRect& floatSrcRect, const FloatSize& scale,
     const FloatPoint& phase, SkXfermode::Mode compositeOp, const FloatRect& destRect, const FloatSize& repeatSpacing)
 {
     TRACE_EVENT0("skia", "Image::drawPattern");
 
     RefPtr<SkImage> image = imageForCurrentFrame();
     if (!image)
         return;
 
     FloatRect normSrcRect = floatSrcRect;
 
@@ skipping 15 matching lines @@
     localMatrix.preScale(scale.width(), scale.height());
 
     // Fetch this now as subsetting may swap the image.
     auto imageID = image->uniqueID();
 
     image = adoptRef(image->newSubset(enclosingIntRect(normSrcRect)));
     if (!image)
         return;
 
     {
-        SkPaint paint = context->fillPaint();
+        SkPaint paint = context.fillPaint();
         paint.setColor(SK_ColorBLACK);
         paint.setXfermodeMode(compositeOp);
-        paint.setFilterQuality(context->computeFilterQuality(this, destRect, normSrcRect));
-        paint.setAntiAlias(context->shouldAntialias());
+        paint.setFilterQuality(context.computeFilterQuality(this, destRect, normSrcRect));
+        paint.setAntiAlias(context.shouldAntialias());
         RefPtr<SkShader> shader = createPatternShader(image.get(), localMatrix, paint,
             FloatSize(repeatSpacing.width() / scale.width(), repeatSpacing.height() / scale.height()));
         paint.setShader(shader.get());
-        context->drawRect(destRect, paint);
+        context.drawRect(destRect, paint);
     }
 
     if (currentFrameIsLazyDecoded())
         PlatformInstrumentation::didDrawLazyPixelRef(imageID);
 }
 
 void Image::computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
 {
     intrinsicRatio = FloatSize(size());
     intrinsicWidth = Length(intrinsicRatio.width(), Fixed);
     intrinsicHeight = Length(intrinsicRatio.height(), Fixed);
 }
 
 PassRefPtr<Image> Image::imageForDefaultFrame()
 {
     RefPtr<Image> image(this);
 
     return image.release();
 }
 
 bool Image::isTextureBacked()
 {
     return imageForCurrentFrame()->isTextureBacked();
 }
 
 } // namespace blink