Fix the way we patch up the matrix for scaled images that aren't

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 "SkBitmapProcState.h"
 #include "SkColorPriv.h"
@@ skipping 113 matching lines @@
         < (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
 }
 
 // TODO -- we may want to pass the clip into this function so we only scale
 // the portion of the image that we're going to need.  This will complicate
 // the interface to the cache, but might be well worth it.
 
 bool SkBitmapProcState::possiblyScaleImage() {
     SkASSERT(NULL == fBitmap);
 
-    fAdjustedMatrix = false;
-
     if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
         return false;
     }
     // Check to see if the transformation matrix is simple, and if we're
     // doing high quality scaling.  If so, do the bitmap scale here and
     // remove the (non-fractional) scaling component from the matrix.
 
     SkScalar invScaleX = fInvMatrix.getScaleX();
     SkScalar invScaleY = fInvMatrix.getScaleY();
 
@@ skipping 45 matching lines @@
             }
 
             SkASSERT(fScaledBitmap.getPixels());
             fScaledBitmap.setImmutable();
             SkBitmapCache::Add(fOrigBitmap, roundedDestWidth, roundedDestHeight, fScaledBitmap);
         }
 
         SkASSERT(fScaledBitmap.getPixels());
         fBitmap = &fScaledBitmap;
 
-        // set the inv matrix type to translate-only;
-        fInvMatrix.setTranslate(fInvMatrix.getTranslateX() / fInvMatrix.getScaleX(),
-                                fInvMatrix.getTranslateY() / fInvMatrix.getScaleY());
+        // clean up the inverse matrix by incorporating the scale we just performed.
 
-#ifndef SK_IGNORE_PROPER_FRACTIONAL_SCALING
-        // reintroduce any fractional scaling missed by our integral scale done above.
-
-       float fractionalScaleX = roundedDestWidth/trueDestWidth;
-       float fractionalScaleY = roundedDestHeight/trueDestHeight;
-
-       fInvMatrix.postScale(fractionalScaleX, fractionalScaleY);
-#endif
-        fAdjustedMatrix = true;
+        fInvMatrix.postScale(roundedDestWidth / fOrigBitmap.width(),
+                             roundedDestHeight / fOrigBitmap.height());
 
         // Set our filter level to low -- the only post-filtering this
         // image might require is some interpolation if the translation
         // is fractional or if there's any remaining scaling to be done.
         fFilterLevel = SkPaint::kLow_FilterLevel;
         return true;
     }
 
     /*
      *  If High, then our special-case for scale-only did not take, and so we
@@ skipping 143 matching lines @@
     // If we are "still" kMedium_FilterLevel, then the request was not fulfilled by possiblyScale,
     // so we downgrade to kLow (so the rest of the sniffing code can assume that)
     if (SkPaint::kMedium_FilterLevel == fFilterLevel) {
         fFilterLevel = SkPaint::kLow_FilterLevel;
     }
 
     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
-    if (!(fAdjustedMatrix || clampClamp || trivialMatrix)) {
-        fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
+    // Most of the scanline procs deal with "unit" texture coordinates, as this
+    // makes it easy to perform tiling modes (repeat = (x & 0xFFFF)). To generate
+    // those, we divide the matrix by its dimensions here.
+    //
+    // We don't do this if we're either trivial (can ignore the matrix) or clamping
+    // in both X and Y since clamping to width,height is just as easy as to 0xFFFF.
+
+    if (!(clampClamp || trivialMatrix)) {
+        fInvMatrix.postIDiv(fBitmap->width(), fBitmap->height());
     }
 
     // Now that all possible changes to the matrix have taken place, check
     // to see if we're really close to a no-scale matrix.  If so, explicitly
     // set it to be so.  Subsequent code may inspect this matrix to choose
     // a faster path in this case.
 
     // This code will only execute if the matrix has some scale component;
     // if it's already pure translate then we won't do this inversion.
 
@@ skipping 682 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }