don't get dismayed by negative scales for HQ

src/core/SkBitmapController.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapController.h"
 #include "SkBitmapProvider.h"
@@ skipping 47 matching lines @@
 // scaling by the given inverted matrix is less than the maximum allowed.
 static inline bool cache_size_okay(const SkBitmapProvider& provider, const SkMatrix& invMat) {
     size_t maximumAllocation = SkResourceCache::GetEffectiveSingleAllocationByteLimit();
     if (0 == maximumAllocation) {
         return true;
     }
     // float matrixScaleFactor = 1.0 / (invMat.scaleX * invMat.scaleY);
     // return ((origBitmapSize * matrixScaleFactor) < maximumAllocationSize);
     // Skip the division step:
     const size_t size = provider.info().getSafeSize(provider.info().minRowBytes());
-    return size < (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
+    SkScalar invScaleSqr = invMat.getScaleX() * invMat.getScaleY();

[vmpstr, 2016/02/04 17:56:07]

I forgot to mention this, but there's another small issue here with rotations.
If we have a rotated image (but otherwise unscaled), then these scales are not
correct. It again doesn't really affect much since it only changes the perceived
amount that the decode requires, but maybe we can rework this and reuse the
scales we get in processHQRequest instead. 

+#ifndef SK_SUPPORT_LEGACY_NEG_SCALE_HQ
+    invScaleSqr = SkScalarAbs(invScaleSqr);
+#endif
+    return size < (maximumAllocation * invScaleSqr);
 }
 
 /*
  *  High quality is implemented by performing up-right scale-only filtering and then
  *  using bilerp for any remaining transformations.
  */
 bool SkDefaultBitmapControllerState::processHQRequest(const SkBitmapProvider& provider) {
     if (fQuality != kHigh_SkFilterQuality) {
         return false;
     }
@@ skipping 11 matching lines @@
     SkScalar invScaleX = fInvMatrix.getScaleX();
     SkScalar invScaleY = fInvMatrix.getScaleY();
     if (fInvMatrix.getType() & SkMatrix::kAffine_Mask) {
         SkSize scale;
         if (!fInvMatrix.decomposeScale(&scale)) {
             return false;
         }
         invScaleX = scale.width();
         invScaleY = scale.height();
     }
+#ifndef SK_SUPPORT_LEGACY_NEG_SCALE_HQ
+    invScaleX = SkScalarAbs(invScaleX);
+    invScaleY = SkScalarAbs(invScaleY);
+#endif
+
     if (SkScalarNearlyEqual(invScaleX, 1) && SkScalarNearlyEqual(invScaleY, 1)) {
         return false; // no need for HQ
     }
 
 #ifndef SK_SUPPORT_LEGACY_HQ_DOWNSAMPLING
     if (invScaleX > 1 || invScaleY > 1) {
         return false; // only use HQ when upsampling
     }
 #endif
     
@@ skipping 110 matching lines @@
                   fResultBitmap.getColorTable());
 }
 
 SkBitmapController::State* SkDefaultBitmapController::onRequestBitmap(const SkBitmapProvider& bm,
                                                                       const SkMatrix& inverse,
                                                                       SkFilterQuality quality,
                                                                       void* storage, size_t size) {
     return SkInPlaceNewCheck<SkDefaultBitmapControllerState>(storage, size, bm, inverse, quality);
 }