Change signature of SkSpecialImage::draw to take SkScalars

src/core/SkSpecialImage.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file
  */
 
 #include "SkCanvas.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 class SkSpecialImage_Base : public SkSpecialImage {
 public:
     SkSpecialImage_Base(const SkIRect& subset) : INHERITED(subset) { }
     virtual ~SkSpecialImage_Base() { }
 
-    virtual void onDraw(SkCanvas*, int x, int y, const SkPaint*) const = 0;
+    virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0;
 
     virtual bool onPeekPixels(SkPixmap*) const { return false; }
 
     virtual GrTexture* onPeekTexture() const { return nullptr; }
 
     virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const { return nullptr; }
 
 private:
     typedef SkSpecialImage INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 static inline const SkSpecialImage_Base* as_IB(const SkSpecialImage* image) {
     return static_cast<const SkSpecialImage_Base*>(image);
 }
 
-void SkSpecialImage::draw(SkCanvas* canvas, int x, int y, const SkPaint* paint) const {
+void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const {
     return as_IB(this)->onDraw(canvas, x, y, paint);
 }
 
 bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const {
     return as_IB(this)->onPeekPixels(pixmap);
 }
 
 GrTexture* SkSpecialImage::peekTexture() const {
     return as_IB(this)->onPeekTexture();
 }
@@ skipping 11 matching lines @@
 
 class SkSpecialImage_Image : public SkSpecialImage_Base {
 public:
     SkSpecialImage_Image(const SkIRect& subset, const SkImage* image)
         : INHERITED(subset)
         , fImage(SkRef(image)) {
     }
 
     ~SkSpecialImage_Image() override { }
 
-    void onDraw(SkCanvas* canvas, int x, int y, const SkPaint* paint) const override {
+    void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y, this->subset().width(), this->subset().height());
 
         canvas->drawImageRect(fImage, this->subset(),
                               dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
     bool onPeekPixels(SkPixmap* pixmap) const override {
         return fImage->peekPixels(pixmap);
     }
 
@@ skipping 44 matching lines @@
         , fBitmap(bm) {
         if (bm.pixelRef()->isPreLocked()) {
             // we only preemptively lock if there is no chance of triggering something expensive
             // like a lazy decode or imagegenerator. PreLocked means it is flat pixels already.
             fBitmap.lockPixels();
         }
     }
 
     ~SkSpecialImage_Raster() override { }
 
-    void onDraw(SkCanvas* canvas, int x, int y, const SkPaint* paint) const override {
+    void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y,
                                       this->subset().width(), this->subset().height());
 
         canvas->drawBitmapRect(fBitmap, this->subset(),
                                dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
     bool onPeekPixels(SkPixmap* pixmap) const override {
         const SkImageInfo info = fBitmap.info();
         if ((kUnknown_SkColorType == info.colorType()) || !fBitmap.getPixels()) {
@@ skipping 31 matching lines @@
 
 class SkSpecialImage_Gpu : public SkSpecialImage_Base {
 public:
     SkSpecialImage_Gpu(const SkIRect& subset, GrTexture* tex)
         : INHERITED(subset)
         , fTexture(SkRef(tex)) {
     }
 
     ~SkSpecialImage_Gpu() override { }
 
-    void onDraw(SkCanvas* canvas, int x, int y, const SkPaint* paint) const override {
+    void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y,
                                       this->subset().width(), this->subset().height());
 
         SkBitmap bm;
 
         static const bool kUnknownOpacity = false;
         GrWrapTextureInBitmap(fTexture,
                               fTexture->width(), fTexture->height(), kUnknownOpacity, &bm);
 
         canvas->drawBitmapRect(bm, this->subset(),
@@ skipping 20 matching lines @@
     return new SkSpecialImage_Gpu(subset, tex);
 }
 
 #else
 
 SkSpecialImage* SkSpecialImage::NewFromGpu(const SkIRect& subset, GrTexture* tex) {
     return nullptr;
 }
 
 #endif