SkTreatAsSprite should take AA into account

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkFloatBits.h"
 #include "SkRSXform.h"
@@ skipping 1605 matching lines @@
 void SkMatrix::toString(SkString* str) const {
     str->appendf("[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]",
              fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5],
              fMat[6], fMat[7], fMat[8]);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkMatrixUtils.h"
 
-bool SkTreatAsSprite(const SkMatrix& mat, int width, int height,
-                     unsigned subpixelBits) {
+bool SkTreatAsSprite(const SkMatrix& mat, const SkISize& size, const SkPaint& paint) {
+    // AA is applied using alpha modulation => 8 bits.
+    static const unsigned kAntiAliasSubpixelBits = 8;

[reed1, 2016/01/07 14:40:50]

we have various AA techniques: paths get 2 subpixel bits per coordinate, rects
are special and get 8. I wonder if we can lower this const to 2 or 4 and see if
things still look pretty. If they do, we might get a perf win.

Speaking of that, we should consider realistic ways to measure the perf win of
treating-as-sprite, just to be sure all of this complexity is actually worth it.

[f(malita), 2016/01/07 15:19:00]

4 seems to work just as well, and it matches the prev filter subpixel value. 
Updated.
Agreed, we should add a bench if we don't already have one.

+
+    const unsigned subpixelBits = paint.isAntiAlias() ? kAntiAliasSubpixelBits : 0;
+
     // quick reject on affine or perspective
     if (mat.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
         return false;
     }
 
     // quick success check
     if (!subpixelBits && !(mat.getType() & ~SkMatrix::kTranslate_Mask)) {
         return true;
     }
 
     // mapRect supports negative scales, so we eliminate those first
     if (mat.getScaleX() < 0 || mat.getScaleY() < 0) {
         return false;
     }
 
     SkRect dst;
-    SkIRect isrc = { 0, 0, width, height };
+    SkIRect isrc = SkIRect::MakeSize(size);
 
     {
         SkRect src;
         src.set(isrc);
         mat.mapRect(&dst, src);
     }
 
     // just apply the translate to isrc
     isrc.offset(SkScalarRoundToInt(mat.getTranslateX()),
                 SkScalarRoundToInt(mat.getTranslateY()));
@@ skipping 137 matching lines @@
     const SkScalar m11 = m00;
     const SkScalar m12 = fTy;
 
     quad[0].set(m02, m12);
     quad[1].set(m00 * width + m02, m10 * width + m12);
     quad[2].set(m00 * width + m01 * height + m02, m10 * width + m11 * height + m12);
     quad[3].set(m01 * height + m02, m11 * height + m12);
 #endif
 }