remove last remnant of SK_SCALAR_IS_FIXED code

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 "Sk64.h"
 #include "SkFloatBits.h"
@@ skipping 295 matching lines @@
     SkMatrix    m;
     m.setScale(sx, sy, px, py);
     return this->preConcat(m);
 }
 
 bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
     if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
         return true;
     }
 
-#ifdef SK_SCALAR_IS_FIXED
-    SkMatrix    m;
-    m.setScale(sx, sy);
-    return this->preConcat(m);
-#else
     // the assumption is that these multiplies are very cheap, and that
     // a full concat and/or just computing the matrix type is more expensive.
     // Also, the fixed-point case checks for overflow, but the float doesn't,
     // so we can get away with these blind multiplies.
 
     fMat[kMScaleX] = SkScalarMul(fMat[kMScaleX], sx);
     fMat[kMSkewY] = SkScalarMul(fMat[kMSkewY],   sx);
     fMat[kMPersp0] = SkScalarMul(fMat[kMPersp0], sx);
 
     fMat[kMSkewX] = SkScalarMul(fMat[kMSkewX],   sy);
     fMat[kMScaleY] = SkScalarMul(fMat[kMScaleY], sy);
     fMat[kMPersp1] = SkScalarMul(fMat[kMPersp1], sy);
 
     this->orTypeMask(kScale_Mask);
     return true;
-#endif
 }
 
 bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
     if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
         return true;
     }
     SkMatrix    m;
     m.setScale(sx, sy, px, py);
     return this->postConcat(m);
 }
 
 bool SkMatrix::postScale(SkScalar sx, SkScalar sy) {
     if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
         return true;
     }
     SkMatrix    m;
     m.setScale(sx, sy);
     return this->postConcat(m);
 }
 
-#ifdef SK_SCALAR_IS_FIXED
-    static inline SkFixed roundidiv(SkFixed numer, int denom) {
-        int ns = numer >> 31;
-        int ds = denom >> 31;
-        numer = (numer ^ ns) - ns;
-        denom = (denom ^ ds) - ds;
-
-        SkFixed answer = (numer + (denom >> 1)) / denom;
-        int as = ns ^ ds;
-        return (answer ^ as) - as;
-    }
-#endif
-
 // this guy perhaps can go away, if we have a fract/high-precision way to
 // scale matrices
 bool SkMatrix::postIDiv(int divx, int divy) {
     if (divx == 0 || divy == 0) {
         return false;
     }
 
-#ifdef SK_SCALAR_IS_FIXED
-    fMat[kMScaleX] = roundidiv(fMat[kMScaleX], divx);
-    fMat[kMSkewX]  = roundidiv(fMat[kMSkewX],  divx);
-    fMat[kMTransX] = roundidiv(fMat[kMTransX], divx);
-
-    fMat[kMScaleY] = roundidiv(fMat[kMScaleY], divy);
-    fMat[kMSkewY]  = roundidiv(fMat[kMSkewY],  divy);
-    fMat[kMTransY] = roundidiv(fMat[kMTransY], divy);
-#else
     const float invX = 1.f / divx;
     const float invY = 1.f / divy;
 
     fMat[kMScaleX] *= invX;
     fMat[kMSkewX]  *= invX;
     fMat[kMTransX] *= invX;
 
     fMat[kMScaleY] *= invY;
     fMat[kMSkewY]  *= invY;
     fMat[kMTransY] *= invY;
-#endif
 
     this->setTypeMask(kUnknown_Mask);
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV,
                          SkScalar px, SkScalar py) {
     const SkScalar oneMinusCosV = SK_Scalar1 - cosV;
@@ skipping 442 matching lines @@
             inv->fMat[kMSkewX]  = SkScalarMulShift(SkPerspMul(fMat[kMTransX], fMat[kMPersp1]) - SkPerspMul(fMat[kMSkewX],  fMat[kMPersp2]), scale, shift);
             inv->fMat[kMTransX] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMTransY]) - SkScalarMul(fMat[kMTransX], fMat[kMScaleY]), scale, shift);
 
             inv->fMat[kMSkewY]  = SkScalarMulShift(SkPerspMul(fMat[kMTransY], fMat[kMPersp0]) - SkPerspMul(fMat[kMSkewY],   fMat[kMPersp2]), scale, shift);
             inv->fMat[kMScaleY] = SkScalarMulShift(SkPerspMul(fMat[kMScaleX], fMat[kMPersp2]) - SkPerspMul(fMat[kMTransX],  fMat[kMPersp0]), scale, shift);
             inv->fMat[kMTransY] = SkScalarMulShift(SkScalarMul(fMat[kMTransX], fMat[kMSkewY]) - SkScalarMul(fMat[kMScaleX], fMat[kMTransY]), scale, shift);
 
             inv->fMat[kMPersp0] = SkScalarMulShift(SkScalarMul(fMat[kMSkewY], fMat[kMPersp1]) - SkScalarMul(fMat[kMScaleY], fMat[kMPersp0]), scale, shift);
             inv->fMat[kMPersp1] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMPersp0]) - SkScalarMul(fMat[kMScaleX], fMat[kMPersp1]), scale, shift);
             inv->fMat[kMPersp2] = SkScalarMulShift(SkScalarMul(fMat[kMScaleX], fMat[kMScaleY]) - SkScalarMul(fMat[kMSkewX], fMat[kMSkewY]), scale, shift);
-#ifdef SK_SCALAR_IS_FIXED
-            if (SkAbs32(inv->fMat[kMPersp2]) > SK_Fixed1) {
-                Sk64    tmp;
-
-                tmp.set(SK_Fract1);
-                tmp.shiftLeft(16);
-                tmp.div(inv->fMat[kMPersp2], Sk64::kRound_DivOption);
-
-                SkFract scale = tmp.get32();
-
-                for (int i = 0; i < 9; i++) {
-                    inv->fMat[i] = SkFractMul(inv->fMat[i], scale);
-                }
-            }
-            inv->fMat[kMPersp2] = SkFixedToFract(inv->fMat[kMPersp2]);
-#endif
         } else {   // not perspective
-#ifdef SK_SCALAR_IS_FIXED
-            Sk64    tx, ty;
-            int     clzNumer;
-
-            // check the 2x2 for overflow
-            {
-                int32_t value = SkAbs32(fMat[kMScaleY]);
-                value |= SkAbs32(fMat[kMSkewX]);
-                value |= SkAbs32(fMat[kMScaleX]);
-                value |= SkAbs32(fMat[kMSkewY]);
-                clzNumer = SkCLZ(value);
-                if (shift - clzNumer > 31)
-                    return false;   // overflow
-            }
-
-            set_muladdmul(&tx, fMat[kMSkewX], fMat[kMTransY], -fMat[kMScaleY], fMat[kMTransX]);
-            set_muladdmul(&ty, fMat[kMSkewY], fMat[kMTransX], -fMat[kMScaleX], fMat[kMTransY]);
-            // check tx,ty for overflow
-            clzNumer = SkCLZ(SkAbs32(tx.fHi) | SkAbs32(ty.fHi));
-            if (shift - clzNumer > 14) {
-                return false;   // overflow
-            }
-
-            int fixedShift = 61 - shift;
-            int sk64shift = 44 - shift + clzNumer;
-
-            inv->fMat[kMScaleX] = SkMulShift(fMat[kMScaleY], scale, fixedShift);
-            inv->fMat[kMSkewX]  = SkMulShift(-fMat[kMSkewX], scale, fixedShift);
-            inv->fMat[kMTransX] = SkMulShift(tx.getShiftRight(33 - clzNumer), scale, sk64shift);
-
-            inv->fMat[kMSkewY]  = SkMulShift(-fMat[kMSkewY], scale, fixedShift);
-            inv->fMat[kMScaleY] = SkMulShift(fMat[kMScaleX], scale, fixedShift);
-            inv->fMat[kMTransY] = SkMulShift(ty.getShiftRight(33 - clzNumer), scale, sk64shift);
-#else
             inv->fMat[kMScaleX] = SkDoubleToFloat(fMat[kMScaleY] * scale);
             inv->fMat[kMSkewX] = SkDoubleToFloat(-fMat[kMSkewX] * scale);
             inv->fMat[kMTransX] = mul_diff_scale(fMat[kMSkewX], fMat[kMTransY],
                                      fMat[kMScaleY], fMat[kMTransX], scale);
 
             inv->fMat[kMSkewY] = SkDoubleToFloat(-fMat[kMSkewY] * scale);
             inv->fMat[kMScaleY] = SkDoubleToFloat(fMat[kMScaleX] * scale);
             inv->fMat[kMTransY] = mul_diff_scale(fMat[kMSkewY], fMat[kMTransX],
                                         fMat[kMScaleX], fMat[kMTransY], scale);
-#endif
+
             inv->fMat[kMPersp0] = 0;
             inv->fMat[kMPersp1] = 0;
             inv->fMat[kMPersp2] = kMatrix22Elem;
 
         }
 
         inv->setTypeMask(fTypeMask);
 
         if (inv == &tmp) {
             *(SkMatrix*)this = tmp;
@@ skipping 101 matching lines @@
             dst->fX = SkScalarMul(sx, mx) + SkScalarMulAdd(sy, kx, tx);
             dst += 1;
         } while (--count);
     }
 }
 
 void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
                          const SkPoint src[], int count) {
     SkASSERT(m.hasPerspective());
 
-#ifdef SK_SCALAR_IS_FIXED
-    SkFixed persp2 = SkFractToFixed(m.fMat[kMPersp2]);
-#endif
-
     if (count > 0) {
         do {
             SkScalar sy = src->fY;
             SkScalar sx = src->fX;
             src += 1;
 
             SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
                          SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
             SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
                          SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-#ifdef SK_SCALAR_IS_FIXED
-            SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
-                        SkFractMul(sy, m.fMat[kMPersp1]) + persp2;
-#else
-            float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
-                      SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
-#endif
+            SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
+                        SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
             if (z) {
                 z = SkScalarFastInvert(z);
             }
 
             dst->fY = SkScalarMul(y, z);
             dst->fX = SkScalarMul(x, z);
             dst += 1;
         } while (--count);
     }
 }
@@ skipping 112 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::Persp_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                         SkPoint* pt) {
     SkASSERT(m.hasPerspective());
 
     SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
                  SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
     SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
                  SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-#ifdef SK_SCALAR_IS_FIXED
-    SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
-                SkFractMul(sy, m.fMat[kMPersp1]) +
-                SkFractToFixed(m.fMat[kMPersp2]);
-#else
-    float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
-              SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
-#endif
+    SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
+                 SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
     if (z) {
         z = SkScalarFastInvert(z);
     }
     pt->fX = SkScalarMul(x, z);
     pt->fY = SkScalarMul(y, z);
 }
 
-#ifdef SK_SCALAR_IS_FIXED
-static SkFixed fixmuladdmul(SkFixed a, SkFixed b, SkFixed c, SkFixed d) {
-    Sk64    tmp, tmp1;
-
-    tmp.setMul(a, b);
-    tmp1.setMul(c, d);
-    return tmp.addGetFixed(tmp1);
-//  tmp.add(tmp1);
-//  return tmp.getFixed();
-}
-#endif
-
 void SkMatrix::RotTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                            SkPoint* pt) {
     SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask)) == kAffine_Mask);
 
-#ifdef SK_SCALAR_IS_FIXED
-    pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]) +
-             m.fMat[kMTransX];
-    pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]) +
-             m.fMat[kMTransY];
-#else
     pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
              SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
     pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
              SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
-#endif
 }
 
 void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                       SkPoint* pt) {
     SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask))== kAffine_Mask);
     SkASSERT(0 == m.fMat[kMTransX]);
     SkASSERT(0 == m.fMat[kMTransY]);
 
-#ifdef SK_SCALAR_IS_FIXED
-    pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]);
-    pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]);
-#else
     pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
              SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
     pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
              SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
-#endif
 }
 
 void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                              SkPoint* pt) {
     SkASSERT((m.getType() & (kScale_Mask | kAffine_Mask | kPerspective_Mask))
              == kScale_Mask);
 
     pt->fX = SkScalarMulAdd(sx, m.fMat[kMScaleX], m.fMat[kMTransX]);
     pt->fY = SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
 }
@@ skipping 33 matching lines @@
     // repeat the persp proc 8 times
     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
     SkMatrix::Persp_xy,    SkMatrix::Persp_xy
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // if its nearly zero (just made up 26, perhaps it should be bigger or smaller)
-#ifdef SK_SCALAR_IS_FIXED
-    typedef SkFract             SkPerspElemType;
-    #define PerspNearlyZero(x)  (SkAbs32(x) < (SK_Fract1 >> 26))
-#else
-    typedef float               SkPerspElemType;
-    #define PerspNearlyZero(x)  SkScalarNearlyZero(x, (1.0f / (1 << 26)))
-#endif
+#define PerspNearlyZero(x)  SkScalarNearlyZero(x, (1.0f / (1 << 26)))
 
 bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
     if (PerspNearlyZero(fMat[kMPersp0])) {
         if (stepX || stepY) {
             if (PerspNearlyZero(fMat[kMPersp1]) &&
                     PerspNearlyZero(fMat[kMPersp2] - kMatrix22Elem)) {
                 if (stepX) {
                     *stepX = SkScalarToFixed(fMat[kMScaleX]);
                 }
                 if (stepY) {
                     *stepY = SkScalarToFixed(fMat[kMSkewY]);
                 }
             } else {
-#ifdef SK_SCALAR_IS_FIXED
-                SkFixed z = SkFractMul(y, fMat[kMPersp1]) +
-                            SkFractToFixed(fMat[kMPersp2]);
-#else
-                float z = y * fMat[kMPersp1] + fMat[kMPersp2];
-#endif
+                SkScalar z = y * fMat[kMPersp1] + fMat[kMPersp2];
                 if (stepX) {
                     *stepX = SkScalarToFixed(SkScalarDiv(fMat[kMScaleX], z));
                 }
                 if (stepY) {
                     *stepY = SkScalarToFixed(SkScalarDiv(fMat[kMSkewY], z));
                 }
             }
         }
         return true;
     }
@@ skipping 46 matching lines @@
         *p++ = x; x += dx;
         *p++ = y; y += dy;
     }
 
     fCount -= n;
     return n;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef SK_SCALAR_IS_FIXED
-
-static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
-    SkFixed x = SK_Fixed1, y = SK_Fixed1;
-    SkPoint pt1, pt2;
-    Sk64    w1, w2;
-
-    if (count > 1) {
-        pt1.fX = poly[1].fX - poly[0].fX;
-        pt1.fY = poly[1].fY - poly[0].fY;
-        y = SkPoint::Length(pt1.fX, pt1.fY);
-        if (y == 0) {
-            return false;
-        }
-        switch (count) {
-            case 2:
-                break;
-            case 3:
-                pt2.fX = poly[0].fY - poly[2].fY;
-                pt2.fY = poly[2].fX - poly[0].fX;
-                goto CALC_X;
-            default:
-                pt2.fX = poly[0].fY - poly[3].fY;
-                pt2.fY = poly[3].fX - poly[0].fX;
-            CALC_X:
-                w1.setMul(pt1.fX, pt2.fX);
-                w2.setMul(pt1.fY, pt2.fY);
-                w1.add(w2);
-                w1.div(y, Sk64::kRound_DivOption);
-                if (!w1.is32()) {
-                    return false;
-                }
-                x = w1.get32();
-                break;
-        }
-    }
-    pt->set(x, y);
-    return true;
-}
-
-bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst,
-                         const SkPoint& scalePt) {
-    // need to check if SkFixedDiv overflows...
-
-    const SkFixed scale = scalePt.fY;
-    dst->fMat[kMScaleX] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
-    dst->fMat[kMSkewY]  = SkFixedDiv(srcPt[0].fX - srcPt[1].fX, scale);
-    dst->fMat[kMPersp0] = 0;
-    dst->fMat[kMSkewX]  = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale);
-    dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
-    dst->fMat[kMPersp1] = 0;
-    dst->fMat[kMTransX] = srcPt[0].fX;
-    dst->fMat[kMTransY] = srcPt[0].fY;
-    dst->fMat[kMPersp2] = SK_Fract1;
-    dst->setTypeMask(kUnknown_Mask);
-    return true;
-}
-
-bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst,
-                         const SkPoint& scale) {
-    // really, need to check if SkFixedDiv overflow'd
-
-    dst->fMat[kMScaleX] = SkFixedDiv(srcPt[2].fX - srcPt[0].fX, scale.fX);
-    dst->fMat[kMSkewY]  = SkFixedDiv(srcPt[2].fY - srcPt[0].fY, scale.fX);
-    dst->fMat[kMPersp0] = 0;
-    dst->fMat[kMSkewX]  = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale.fY);
-    dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale.fY);
-    dst->fMat[kMPersp1] = 0;
-    dst->fMat[kMTransX] = srcPt[0].fX;
-    dst->fMat[kMTransY] = srcPt[0].fY;
-    dst->fMat[kMPersp2] = SK_Fract1;
-    dst->setTypeMask(kUnknown_Mask);
-    return true;
-}
-
-bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
-                         const SkPoint& scale) {
-    SkFract a1, a2;
-    SkFixed x0, y0, x1, y1, x2, y2;
-
-    x0 = srcPt[2].fX - srcPt[0].fX;
-    y0 = srcPt[2].fY - srcPt[0].fY;
-    x1 = srcPt[2].fX - srcPt[1].fX;
-    y1 = srcPt[2].fY - srcPt[1].fY;
-    x2 = srcPt[2].fX - srcPt[3].fX;
-    y2 = srcPt[2].fY - srcPt[3].fY;
-
-    /* check if abs(x2) > abs(y2) */
-    if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2) {
-        SkFixed denom = SkMulDiv(x1, y2, x2) - y1;
-        if (0 == denom) {
-            return false;
-        }
-        a1 = SkFractDiv(SkMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
-    } else {
-        SkFixed denom = x1 - SkMulDiv(y1, x2, y2);
-        if (0 == denom) {
-            return false;
-        }
-        a1 = SkFractDiv(x0 - x1 - SkMulDiv(y0 - y1, x2, y2), denom);
-    }
-
-    /* check if abs(x1) > abs(y1) */
-    if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1) {
-        SkFixed denom = y2 - SkMulDiv(x2, y1, x1);
-        if (0 == denom) {
-            return false;
-        }
-        a2 = SkFractDiv(y0 - y2 - SkMulDiv(x0 - x2, y1, x1), denom);
-    } else {
-        SkFixed denom = SkMulDiv(y2, x1, y1) - x2;
-        if (0 == denom) {
-            return false;
-        }
-        a2 = SkFractDiv(SkMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
-    }
-
-    // need to check if SkFixedDiv overflows...
-    dst->fMat[kMScaleX] = SkFixedDiv(SkFractMul(a2, srcPt[3].fX) +
-                                     srcPt[3].fX - srcPt[0].fX, scale.fX);
-    dst->fMat[kMSkewY]  = SkFixedDiv(SkFractMul(a2, srcPt[3].fY) +
-                                     srcPt[3].fY - srcPt[0].fY, scale.fX);
-    dst->fMat[kMPersp0] = SkFixedDiv(a2, scale.fX);
-    dst->fMat[kMSkewX]  = SkFixedDiv(SkFractMul(a1, srcPt[1].fX) +
-                                     srcPt[1].fX - srcPt[0].fX, scale.fY);
-    dst->fMat[kMScaleY] = SkFixedDiv(SkFractMul(a1, srcPt[1].fY) +
-                                     srcPt[1].fY - srcPt[0].fY, scale.fY);
-    dst->fMat[kMPersp1] = SkFixedDiv(a1, scale.fY);
-    dst->fMat[kMTransX] = srcPt[0].fX;
-    dst->fMat[kMTransY] = srcPt[0].fY;
-    dst->fMat[kMPersp2] = SK_Fract1;
-    dst->setTypeMask(kUnknown_Mask);
-    return true;
-}
-
-#else   /* Scalar is float */
-
 static inline bool checkForZero(float x) {
     return x*x == 0;
 }
 
 static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
     float   x = 1, y = 1;
     SkPoint pt1, pt2;
 
     if (count > 1) {
         pt1.fX = poly[1].fX - poly[0].fX;
@@ skipping 112 matching lines @@
     dst->fMat[kMScaleY] = SkScalarMul(SkScalarMul(a1, srcPt[1].fY) +
                                       srcPt[1].fY - srcPt[0].fY, invScale);
     dst->fMat[kMPersp1] = SkScalarMul(a1, invScale);
     dst->fMat[kMTransX] = srcPt[0].fX;
     dst->fMat[kMTransY] = srcPt[0].fY;
     dst->fMat[kMPersp2] = 1;
     dst->setTypeMask(kUnknown_Mask);
     return true;
 }
 
-#endif
-
 typedef bool (*PolyMapProc)(const SkPoint[], SkMatrix*, const SkPoint&);
 
 /*  Taken from Rob Johnson's original sample code in QuickDraw GX
 */
 bool SkMatrix::setPolyToPoly(const SkPoint src[], const SkPoint dst[],
                              int count) {
     if ((unsigned)count > 4) {
         SkDebugf("--- SkMatrix::setPolyToPoly count out of range %d\n", count);
         return false;
     }
@@ skipping 315 matching lines @@
         rotation1->fX = cos1;
         rotation1->fY = sin1;
     }
     if (NULL != rotation2) {
         rotation2->fX = cos2;
         rotation2->fY = sin2;
     }
 
     return true;
 }