add SkMatrixPriv for specialized helpers

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 "SkFloatBits.h"
 #include "SkMatrix.h"
 #include "SkNx.h"
@@ skipping 1084 matching lines @@
         }
     } else {
         SkMatrix tmp = *this;
 
         tmp.fMat[kMTransX] = tmp.fMat[kMTransY] = 0;
         tmp.clearTypeMask(kTranslate_Mask);
         tmp.mapPoints(dst, src, count);
     }
 }
 
+static Sk4f sort_as_rect(const Sk4f& ltrb) {
+    Sk4f rblt(ltrb[2], ltrb[3], ltrb[0], ltrb[1]);
+    Sk4f min = Sk4f::Min(ltrb, rblt);
+    Sk4f max = Sk4f::Max(ltrb, rblt);
+    // We can extract either pair [0,1] or [2,3] from min and max and be correct, but on
+    // ARM this sequence generates the fastest (a single instruction).
+    return Sk4f(min[2], min[3], max[0], max[1]);
+}
+
 void SkMatrix::mapRectScaleTranslate(SkRect* dst, const SkRect& src) const {
     SkASSERT(dst);
     SkASSERT(this->isScaleTranslate());
 
     SkScalar sx = fMat[kMScaleX];
     SkScalar sy = fMat[kMScaleY];
     SkScalar tx = fMat[kMTransX];
     SkScalar ty = fMat[kMTransY];
     Sk4f scale(sx, sy, sx, sy);
     Sk4f trans(tx, ty, tx, ty);
-
-    Sk4f ltrb = Sk4f::Load(&src.fLeft) * scale + trans;
-    // need to sort so we're not inverted
-    Sk4f rblt(ltrb[2], ltrb[3], ltrb[0], ltrb[1]);
-    Sk4f min = Sk4f::Min(ltrb, rblt);
-    Sk4f max = Sk4f::Max(ltrb, rblt);
-    // We can extract either pair [0,1] or [2,3] from min and max and be correct, but on
-    // ARM this sequence generates the fastest (a single instruction).
-    Sk4f(min[2], min[3], max[0], max[1]).store(&dst->fLeft);
+    sort_as_rect(Sk4f::Load(&src.fLeft) * scale + trans).store(&dst->fLeft);
 }
 
 bool SkMatrix::mapRect(SkRect* dst, const SkRect& src) const {
     SkASSERT(dst);
 
+    if (this->getType() <= kTranslate_Mask) {
+        SkScalar tx = fMat[kMTransX];
+        SkScalar ty = fMat[kMTransY];
+        Sk4f trans(tx, ty, tx, ty);
+        sort_as_rect(Sk4f::Load(&src.fLeft) + trans).store(&dst->fLeft);
+        return true;
+    }
     if (this->isScaleTranslate()) {
         this->mapRectScaleTranslate(dst, src);
         return true;
     } else {
         SkPoint quad[4];
 
         src.toQuad(quad);
         this->mapPoints(quad, quad, 4);
         dst->set(quad, 4);
         return false;
@@ skipping 752 matching lines @@
     const SkScalar m10 = -m01;
     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
 }