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 = SkScalarAbs(invMat.getScaleX() * invMat.getScaleY());
+    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();
     }
+    invScaleX = SkScalarAbs(invScaleX);

[vmpstr, 2016/02/04 00:59:04]

This is the only bit that requires some thought for me. I think this is OK,
since we won't undo the flip as a result (ie the matrix would retain the fact
that the image is flipped). 

+    invScaleY = SkScalarAbs(invScaleY);
+
     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);
 }