Rename SkBitmapProcStateAutoMapper methods

src/core/SkBitmapProcState.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 "SkBitmapCache.h"
 #include "SkBitmapController.h"
 #include "SkBitmapProcState.h"
@@ skipping 482 matching lines @@
 
         if (s.fInvType > SkMatrix::kTranslate_Mask) {
             const SkBitmapProcStateAutoMapper mapper(s, x, y);
 
             // When the matrix has a scale component the setup code in
             // chooseProcs multiples the inverse matrix by the inverse of the
             // bitmap's width and height. Since this method is going to do
             // its own tiling and sampling we need to undo that here.
             if (SkShader::kClamp_TileMode != s.fTileModeX ||
                 SkShader::kClamp_TileMode != s.fTileModeY) {
-                yTemp = SkFractionalIntToInt(mapper.y() * s.fPixmap.height());
+                yTemp = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
             } else {
-                yTemp = SkFractionalIntToInt(mapper.y());
+                yTemp = mapper.intY();
             }
         } else {
             yTemp = s.fFilterOneY + y;
         }
 
         const int stopY = s.fPixmap.height();
         switch (s.fTileModeY) {
             case SkShader::kClamp_TileMode:
                 iY0 = SkClampMax(yTemp, stopY-1);
                 break;
             case SkShader::kRepeat_TileMode:
                 iY0 = sk_int_mod(yTemp, stopY);
                 break;
             case SkShader::kMirror_TileMode:
             default:
                 iY0 = sk_int_mirror(yTemp, stopY);
                 break;
         }
 
 #ifdef SK_DEBUG
         {
             const SkBitmapProcStateAutoMapper mapper(s, x, y);
             int iY2;
 
             if (s.fInvType > SkMatrix::kTranslate_Mask &&
                 (SkShader::kClamp_TileMode != s.fTileModeX ||
                  SkShader::kClamp_TileMode != s.fTileModeY)) {
-                iY2 = SkFractionalIntToInt(mapper.y() * s.fPixmap.height());
+                iY2 = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
             } else {
-                iY2 = SkFractionalIntToInt(mapper.y());
+                iY2 = mapper.intY();
             }
 
             switch (s.fTileModeY) {
             case SkShader::kClamp_TileMode:
                 iY2 = SkClampMax(iY2, stopY-1);
                 break;
             case SkShader::kRepeat_TileMode:
                 iY2 = sk_int_mod(iY2, stopY);
                 break;
             case SkShader::kMirror_TileMode:
@@ skipping 45 matching lines @@
      *  negate it.
      */
     const SkScalar too_big = SkIntToScalar(1 << 30);
     if (SkScalarAbs(pt.fX) > too_big || SkScalarAbs(pt.fY) > too_big) {
         return false;
     }
 
     // Since we know we're not filtered, we re-purpose these fields allow
     // us to go from device -> src coordinates w/ just an integer add,
     // rather than running through the inverse-matrix
-    fFilterOneX = SkFractionalIntToInt(mapper.x());
-    fFilterOneY = SkFractionalIntToInt(mapper.y());
+    fFilterOneX = mapper.intX();
+    fFilterOneY = mapper.intY();
 
     return true;
 }
 
 SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
 
     if (kN32_SkColorType != fPixmap.colorType()) {
         return nullptr;
     }
 
@@ skipping 161 matching lines @@
     const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                              SkMatrix::kScale_Mask)) == 0);
 
     const unsigned maxX = s.fPixmap.width() - 1;
     SkFractionalInt fx;
     int dstY;
     {
         const SkBitmapProcStateAutoMapper mapper(s, x, y);
         const unsigned maxY = s.fPixmap.height() - 1;
-        dstY = SkClampMax(SkFractionalIntToInt(mapper.y()), maxY);
-        fx = mapper.x();
+        dstY = SkClampMax(mapper.intY(), maxY);
+        fx = mapper.fractionalIntX();
     }
 
     const SkPMColor* SK_RESTRICT src = s.fPixmap.addr32(0, dstY);
     const SkFractionalInt dx = s.fInvSxFractionalInt;
 
     // Check if we're safely inside [0...maxX] so no need to clamp each computed index.
     //
     if ((uint64_t)SkFractionalIntToInt(fx) <= maxX &&
         (uint64_t)SkFractionalIntToInt(fx + dx * (count - 1)) <= maxX)
     {
@@ skipping 16 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }