Remove SkCanvas::drawBitmapMatrix()

src/pdf/SkPDFShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
@@ skipping 997 matching lines @@
     canvas.drawBitmap(*image, 0, 0);
 
     SkScalar width = SkIntToScalar(image->width());
     SkScalar height = SkIntToScalar(image->height());
 
     // Tiling is implied.  First we handle mirroring.
     if (tileModes[0] == SkShader::kMirror_TileMode) {
         SkMatrix xMirror;
         xMirror.setScale(-1, 1);
         xMirror.postTranslate(2 * width, 0);
-        canvas.drawBitmapMatrix(*image, xMirror);

[mtklein, 2014/12/10 14:48:09]

Seems like this file uses drawBitmapMatrix often enough that we might want to
recreate it as a static function, particularly because we're forced to manually
scope the save/restore blocks so often.

[f(malita), 2014/12/10 15:33:56]

Done.

+
+        SkAutoCanvasRestore acr(&canvas, true);
+        canvas.concat(xMirror);
+        canvas.drawBitmap(*image, 0, 0);
+
         patternBBox.fRight += width;
     }
     if (tileModes[1] == SkShader::kMirror_TileMode) {
         SkMatrix yMirror;
         yMirror.setScale(SK_Scalar1, -SK_Scalar1);
         yMirror.postTranslate(0, 2 * height);
-        canvas.drawBitmapMatrix(*image, yMirror);
+
+        SkAutoCanvasRestore acr(&canvas, true);
+        canvas.concat(yMirror);
+        canvas.drawBitmap(*image, 0, 0);
+
         patternBBox.fBottom += height;
     }
     if (tileModes[0] == SkShader::kMirror_TileMode &&
             tileModes[1] == SkShader::kMirror_TileMode) {
         SkMatrix mirror;
         mirror.setScale(-1, -1);
         mirror.postTranslate(2 * width, 2 * height);
-        canvas.drawBitmapMatrix(*image, mirror);
+
+        SkAutoCanvasRestore acr(&canvas, true);
+        canvas.concat(mirror);
+        canvas.drawBitmap(*image, 0, 0);
     }
 
     // Then handle Clamping, which requires expanding the pattern canvas to
     // cover the entire surfaceBBox.
 
     // If both x and y are in clamp mode, we start by filling in the corners.
     // (Which are just a rectangles of the corner colors.)
     if (tileModes[0] == SkShader::kClamp_TileMode &&
             tileModes[1] == SkShader::kClamp_TileMode) {
         SkPaint paint;
@@ skipping 30 matching lines @@
     // Then expand the left, right, top, then bottom.
     if (tileModes[0] == SkShader::kClamp_TileMode) {
         SkIRect subset = SkIRect::MakeXYWH(0, 0, 1, image->height());
         if (deviceBounds.left() < 0) {
             SkBitmap left;
             SkAssertResult(image->extractSubset(&left, subset));
 
             SkMatrix leftMatrix;
             leftMatrix.setScale(-deviceBounds.left(), 1);
             leftMatrix.postTranslate(deviceBounds.left(), 0);
-            canvas.drawBitmapMatrix(left, leftMatrix);
+
+            {
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(leftMatrix);
+                canvas.drawBitmap(left, 0, 0);
+            }
 
             if (tileModes[1] == SkShader::kMirror_TileMode) {
                 leftMatrix.postScale(SK_Scalar1, -SK_Scalar1);
                 leftMatrix.postTranslate(0, 2 * height);
-                canvas.drawBitmapMatrix(left, leftMatrix);
+
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(leftMatrix);
+                canvas.drawBitmap(left, 0, 0);
             }
             patternBBox.fLeft = 0;
         }
 
         if (deviceBounds.right() > width) {
             SkBitmap right;
             subset.offset(image->width() - 1, 0);
             SkAssertResult(image->extractSubset(&right, subset));
 
             SkMatrix rightMatrix;
             rightMatrix.setScale(deviceBounds.right() - width, 1);
             rightMatrix.postTranslate(width, 0);
-            canvas.drawBitmapMatrix(right, rightMatrix);
+
+            {
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(rightMatrix);
+                canvas.drawBitmap(right, 0, 0);
+            }
 
             if (tileModes[1] == SkShader::kMirror_TileMode) {
                 rightMatrix.postScale(SK_Scalar1, -SK_Scalar1);
                 rightMatrix.postTranslate(0, 2 * height);
-                canvas.drawBitmapMatrix(right, rightMatrix);
+
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(rightMatrix);
+                canvas.drawBitmap(right, 0, 0);
             }
             patternBBox.fRight = deviceBounds.width();
         }
     }
 
     if (tileModes[1] == SkShader::kClamp_TileMode) {
         SkIRect subset = SkIRect::MakeXYWH(0, 0, image->width(), 1);
         if (deviceBounds.top() < 0) {
             SkBitmap top;
             SkAssertResult(image->extractSubset(&top, subset));
 
             SkMatrix topMatrix;
             topMatrix.setScale(SK_Scalar1, -deviceBounds.top());
             topMatrix.postTranslate(0, deviceBounds.top());
-            canvas.drawBitmapMatrix(top, topMatrix);
+
+            {
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(topMatrix);
+                canvas.drawBitmap(top, 0, 0);
+            }
 
             if (tileModes[0] == SkShader::kMirror_TileMode) {
                 topMatrix.postScale(-1, 1);
                 topMatrix.postTranslate(2 * width, 0);
-                canvas.drawBitmapMatrix(top, topMatrix);
+
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(topMatrix);
+                canvas.drawBitmap(top, 0, 0);
             }
             patternBBox.fTop = 0;
         }
 
         if (deviceBounds.bottom() > height) {
             SkBitmap bottom;
             subset.offset(0, image->height() - 1);
             SkAssertResult(image->extractSubset(&bottom, subset));
 
             SkMatrix bottomMatrix;
             bottomMatrix.setScale(SK_Scalar1, deviceBounds.bottom() - height);
             bottomMatrix.postTranslate(0, height);
-            canvas.drawBitmapMatrix(bottom, bottomMatrix);
+
+            {
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(bottomMatrix);
+                canvas.drawBitmap(bottom, 0, 0);
+            }
 
             if (tileModes[0] == SkShader::kMirror_TileMode) {
                 bottomMatrix.postScale(-1, 1);
                 bottomMatrix.postTranslate(2 * width, 0);
-                canvas.drawBitmapMatrix(bottom, bottomMatrix);
+
+                SkAutoCanvasRestore acr(&canvas, true);
+                canvas.concat(bottomMatrix);
+                canvas.drawBitmap(bottom, 0, 0);
             }
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
     SkAutoTUnref<SkStream> content(pattern.content());
     setData(content.get());
     SkPDFResourceDict* resourceDict = pattern.getResourceDict();
     resourceDict->getReferencedResources(fResources, &fResources, false);
@@ skipping 177 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }