Remove SkCanvas::drawBitmapMatrix()

gm/bitmapmatrix.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gm.h"
 #include "SkBitmap.h"
 #include "SkBlurMask.h"
@@ skipping 11 matching lines @@
 class DrawBitmapMatrixGM : public GM {
 public:
     DrawBitmapMatrixGM() {}
 
 protected:
     virtual uint32_t onGetFlags() const SK_OVERRIDE {
         return kSkipTiled_Flag;
     }
 
     virtual SkString onShortName() SK_OVERRIDE {
         return SkString("drawbitmapmatrix");

[f(malita), 2014/12/09 23:50:08]

Should we just remove this GM instead of converting? Not sure whether it
exercises any interesting bitmap paths.

     }
 
     virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(1024, 256); }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         SkBitmap bm;
         this->setupBitmap(&bm);
 
         // Draw normally.
         SkMatrix matrix;
         matrix.reset();
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setDither(true);
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        canvas->drawBitmap(bm, 0, 0, &paint);
 
         // Draw stretched horizontally and squished vertically.
         canvas->translate(SkIntToScalar(bm.width() + 5), 0);
         matrix.setScale(SkIntToScalar(2), SK_ScalarHalf);
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->concat(matrix);
+            canvas->drawBitmap(bm, 0, 0, &paint);
+        }
 
         // Draw rotated
         canvas->translate(SkIntToScalar(bm.width()*2 + 5), 0);
         matrix.reset();
         matrix.setRotate(SkIntToScalar(45), SkIntToScalar(bm.width() / 2),
                          SkIntToScalar(bm.height() / 2));
         canvas->save();
         canvas->translate(0, SkIntToScalar(10));
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        canvas->concat(matrix);
+        canvas->drawBitmap(bm, 0, 0, &paint);
         canvas->restore();
 
         // Draw with perspective
         canvas->translate(SkIntToScalar(bm.width() + 15), 0);
         matrix.reset();
         matrix.setPerspX(SkScalarDiv(SK_Scalar1, SkIntToScalar(1000)));
         matrix.setPerspY(SkScalarDiv(SK_Scalar1, SkIntToScalar(1000)));
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->concat(matrix);
+            canvas->drawBitmap(bm, 0, 0, &paint);
+        }
 
         // Draw with skew
         canvas->translate(SkIntToScalar(bm.width() + 5), 0);
         matrix.reset();
         matrix.setSkew(SkIntToScalar(2), SkIntToScalar(2));
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->concat(matrix);
+            canvas->drawBitmap(bm, 0, 0, &paint);
+        }
 
         // Draw with sin/cos
         canvas->translate(SkIntToScalar(bm.width() * 4), 0);
         matrix.reset();
         matrix.setSinCos(SK_ScalarHalf, SkIntToScalar(2));
-        canvas->drawBitmapMatrix(bm, matrix, &paint);
+        {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->concat(matrix);
+            canvas->drawBitmap(bm, 0, 0, &paint);
+        }
 
         {
             // test the following code path:
             // SkGpuDevice::drawPath() -> SkGpuDevice::drawWithMaskFilter()
             SkPaint paint;
 
             paint.setFilterLevel(SkPaint::kLow_FilterLevel);
 
             SkMaskFilter* mf = SkBlurMaskFilter::Create(
                 kNormal_SkBlurStyle,
                 SkBlurMask::ConvertRadiusToSigma(5),
                 SkBlurMaskFilter::kHighQuality_BlurFlag |
                 SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
             paint.setMaskFilter(mf)->unref();
 
             canvas->translate(SkIntToScalar(bm.width()*2 + 20), 0);
 
             matrix.reset();
             matrix.setRotate(SkIntToScalar(45), SkIntToScalar(bm.width() / 2),
                              SkIntToScalar(bm.height() / 2));
 
             canvas->save();
             canvas->translate(0, SkIntToScalar(20));
-            canvas->drawBitmapMatrix(bm, matrix, &paint);
+            canvas->concat(matrix);
+            canvas->drawBitmap(bm, 0, 0, &paint);
             canvas->restore();
         }
 
     }
 private:
     void setupBitmap(SkBitmap* bm) {
         SkASSERT(bm);
         static const int SIZE = 64;
         bm->allocN32Pixels(SIZE, SIZE);
         SkCanvas canvas(*bm);
@@ skipping 10 matching lines @@
         canvas.drawPath(path, paint);
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static GM* MyFactory(void*) { return new DrawBitmapMatrixGM; }
 static GMRegistry reg(MyFactory);
 
 }