Replace ResamplingMode with InterpolationQuality.

Source/platform/graphics/skia/NativeImageSkia.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkScalar.h"
 #include "third_party/skia/include/core/SkShader.h"
 
+#include <algorithm>
 #include <math.h>
 #include <limits>
 
 namespace WebCore {
 
 static bool nearlyIntegral(float value)
 {
     return fabs(value - floorf(value)) < std::numeric_limits<float>::epsilon();
 }
 
-ResamplingMode NativeImageSkia::computeResamplingMode(const SkMatrix& matrix, float srcWidth, float srcHeight, float destWidth, float destHeight) const
+InterpolationQuality NativeImageSkia::computeInterpolationQuality(const SkMatrix& matrix, float srcWidth, float srcHeight, float destWidth, float destHeight) const
 {
     // The percent change below which we will not resample. This usually means
     // an off-by-one error on the web page, and just doing nearest neighbor
     // sampling is usually good enough.
     const float kFractionalChangeThreshold = 0.025f;
 
     // Images smaller than this in either direction are considered "small" and
     // are not resampled ever (see below).
     const int kSmallImageSizeThreshold = 8;
 
     // The amount an image can be stretched in a single direction before we
     // say that it is being stretched so much that it must be a line or
     // background that doesn't need resampling.
     const float kLargeStretch = 3.0f;
 
     // Figure out if we should resample this image. We try to prune out some
     // common cases where resampling won't give us anything, since it is much
     // slower than drawing stretched.
     float diffWidth = fabs(destWidth - srcWidth);
     float diffHeight = fabs(destHeight - srcHeight);
     bool widthNearlyEqual = diffWidth < std::numeric_limits<float>::epsilon();
     bool heightNearlyEqual = diffHeight < std::numeric_limits<float>::epsilon();
     // We don't need to resample if the source and destination are the same.
     if (widthNearlyEqual && heightNearlyEqual)
-        return NoResampling;
+        return InterpolationNone;
 
     if (srcWidth <= kSmallImageSizeThreshold
         || srcHeight <= kSmallImageSizeThreshold
         || destWidth <= kSmallImageSizeThreshold
         || destHeight <= kSmallImageSizeThreshold) {
         // Small image detected.
 
         // Resample in the case where the new size would be non-integral.
         // This can cause noticeable breaks in repeating patterns, except
         // when the source image is only one pixel wide in that dimension.
         if ((!nearlyIntegral(destWidth) && srcWidth > 1 + std::numeric_limits<float>::epsilon())
             || (!nearlyIntegral(destHeight) && srcHeight > 1 + std::numeric_limits<float>::epsilon()))
-            return LinearResampling;
+            return InterpolationLow;
 
         // Otherwise, don't resample small images. These are often used for
         // borders and rules (think 1x1 images used to make lines).
-        return NoResampling;
+        return InterpolationNone;
     }
 
     if (srcHeight * kLargeStretch <= destHeight || srcWidth * kLargeStretch <= destWidth) {
         // Large image detected.
 
         // Don't resample if it is being stretched a lot in only one direction.
         // This is trying to catch cases where somebody has created a border
         // (which might be large) and then is stretching it to fill some part
         // of the page.
         if (widthNearlyEqual || heightNearlyEqual)
-            return NoResampling;
+            return InterpolationNone;
 
         // The image is growing a lot and in more than one direction. Resampling
         // is slow and doesn't give us very much when growing a lot.
-        return LinearResampling;
+        return InterpolationLow;
     }
 
     if ((diffWidth / srcWidth < kFractionalChangeThreshold)
         && (diffHeight / srcHeight < kFractionalChangeThreshold)) {
         // It is disappointingly common on the web for image sizes to be off by
         // one or two pixels. We don't bother resampling if the size difference
         // is a small fraction of the original size.
-        return NoResampling;
+        return InterpolationNone;
     }
 
     // When the image is not yet done loading, use linear. We don't cache the
     // partially resampled images, and as they come in incrementally, it causes
     // us to have to resample the whole thing every time.
     if (!isDataComplete())
-        return LinearResampling;
+        return InterpolationLow;
 
     // Everything else gets resampled.
     // High quality interpolation only enabled for scaling and translation.
     if (!(matrix.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)))
-        return AwesomeResampling;
+        return InterpolationHigh;
 
-    return LinearResampling;
+    return InterpolationLow;
 }
 
-static ResamplingMode limitResamplingMode(GraphicsContext* context, ResamplingMode resampling)
+static InterpolationQuality limitInterpolationQuality(GraphicsContext* context, InterpolationQuality resampling)
 {
-    switch (context->imageInterpolationQuality()) {
-    case InterpolationNone:
-        return NoResampling;
-    case InterpolationMedium:
-        if (resampling == AwesomeResampling)
-            return LinearWithMipmapsResampling;
-        break;
-    case InterpolationLow:
-        if (resampling == AwesomeResampling || resampling == LinearWithMipmapsResampling)
-            return LinearResampling;
-        break;
-    case InterpolationHigh:
-        break;
-    }
-
-    return resampling;
+    return std::min(resampling, context->imageInterpolationQuality());
 }
 
-static SkPaint::FilterLevel convertToSkiaFilterLevel(bool useBicubicFilter, ResamplingMode resampling)
+static SkPaint::FilterLevel convertToSkiaFilterLevel(bool useBicubicFilter, InterpolationQuality resampling)
 {
+    // FIXME: If we get rid of this special case, this function can go away entirely.
     if (useBicubicFilter)
         return SkPaint::kHigh_FilterLevel;
 
-    switch (resampling) {
-    case LinearWithMipmapsResampling:
-        return SkPaint::kMedium_FilterLevel;
-    case LinearResampling:
-        return SkPaint::kLow_FilterLevel;
-    // AwesomeResampling if useBicubicFilter is false means that we do
+    // InterpolationHigh if useBicubicFilter is false means that we do
     // a manual high quality resampling before drawing to Skia.
-    case AwesomeResampling:
-    default:
+    if (resampling == InterpolationHigh)
         return SkPaint::kNone_FilterLevel;
-    }
+
+    return static_cast<SkPaint::FilterLevel>(resampling);
 }
 
 // This function is used to scale an image and extract a scaled fragment.
 //
 // ALGORITHM
 //
 // Because the scaled image size has to be integers, we approximate the real
 // scale with the following formula (only X direction is shown):
 //
 // scaledImageWidth = round(scaleX * imageRect.width())
@@ skipping 183 matching lines @@
     TRACE_EVENT0("skia", "NativeImageSkia::draw");
     SkPaint paint;
     paint.setXfermode(compOp.get());
     paint.setColorFilter(context->colorFilter());
     paint.setAlpha(context->getNormalizedAlpha());
     paint.setLooper(context->drawLooper());
     paint.setAntiAlias(shouldDrawAntiAliased(context, destRect));
 
     bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap());
 
-    ResamplingMode resampling;
+    InterpolationQuality resampling;
     if (context->isAccelerated()) {
-        resampling = LinearResampling;
+        resampling = InterpolationLow;
     } else if (context->printing()) {
-        resampling = NoResampling;
+        resampling = InterpolationNone;
     } else if (isLazyDecoded) {
-        resampling = AwesomeResampling;
+        resampling = InterpolationHigh;
     } else {
         // Take into account scale applied to the canvas when computing sampling mode (e.g. CSS scale or page scale).
         SkRect destRectTarget = destRect;
         SkMatrix totalMatrix = context->getTotalMatrix();
         if (!(totalMatrix.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)))
             totalMatrix.mapRect(&destRectTarget, destRect);
 
-        resampling = computeResamplingMode(totalMatrix,
+        resampling = computeInterpolationQuality(totalMatrix,
             SkScalarToFloat(srcRect.width()), SkScalarToFloat(srcRect.height()),
             SkScalarToFloat(destRectTarget.width()), SkScalarToFloat(destRectTarget.height()));
     }
 
-    if (resampling == NoResampling) {
+    if (resampling == InterpolationNone) {
         // FIXME: This is to not break tests (it results in the filter bitmap flag
-        // being set to true). We need to decide if we respect NoResampling
-        // being returned from computeResamplingMode.
-        resampling = LinearResampling;
+        // being set to true). We need to decide if we respect InterpolationNone
+        // being returned from computeInterpolationQuality.
+        resampling = InterpolationLow;
     }
-    resampling = limitResamplingMode(context, resampling);
+    resampling = limitInterpolationQuality(context, resampling);
 
     // FIXME: Bicubic filtering in Skia is only applied to defer-decoded images
     // as an experiment. Once this filtering code path becomes stable we should
     // turn this on for all cases, including non-defer-decoded images.
-    bool useBicubicFilter = resampling == AwesomeResampling && isLazyDecoded;
+    bool useBicubicFilter = resampling == InterpolationHigh && isLazyDecoded;
 
     paint.setFilterLevel(convertToSkiaFilterLevel(useBicubicFilter, resampling));
 
-    if (resampling == AwesomeResampling && !useBicubicFilter) {
+    if (resampling == InterpolationHigh && !useBicubicFilter) {
         // Resample the image and then draw the result to canvas with bilinear
         // filtering.
         drawResampledBitmap(context, paint, srcRect, destRect);
     } else {
         // We want to filter it if we decided to do interpolation above, or if
         // there is something interesting going on with the matrix (like a rotation).
         // Note: for serialization, we will want to subset the bitmap first so we
         // don't send extra pixels.
         context->drawBitmapRect(bitmap(), &srcRect, destRect, &paint);
     }
@@ skipping 43 matching lines @@
     // matrix to see how big it will be.
     SkRect destRectTarget;
     totalMatrix.mapRect(&destRectTarget, normSrcRect);
 
     float destBitmapWidth = SkScalarToFloat(destRectTarget.width());
     float destBitmapHeight = SkScalarToFloat(destRectTarget.height());
 
     bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap());
 
     // Compute the resampling mode.
-    ResamplingMode resampling;
+    InterpolationQuality resampling;
     if (context->isAccelerated() || context->printing())
-        resampling = LinearResampling;
+        resampling = InterpolationLow;
     else if (isLazyDecoded)
-        resampling = AwesomeResampling;
+        resampling = InterpolationHigh;
     else
-        resampling = computeResamplingMode(totalMatrix, normSrcRect.width(), normSrcRect.height(), destBitmapWidth, destBitmapHeight);
-    resampling = limitResamplingMode(context, resampling);
+        resampling = computeInterpolationQuality(totalMatrix, normSrcRect.width(), normSrcRect.height(), destBitmapWidth, destBitmapHeight);
+    resampling = limitInterpolationQuality(context, resampling);
 
     SkMatrix localMatrix;
     // We also need to translate it such that the origin of the pattern is the
     // origin of the destination rect, which is what WebKit expects. Skia uses
     // the coordinate system origin as the base for the pattern. If WebKit wants
     // a shifted image, it will shift it from there using the localMatrix.
     const float adjustedX = phase.x() + normSrcRect.x() * scale.width();
     const float adjustedY = phase.y() + normSrcRect.y() * scale.height();
     localMatrix.setTranslate(SkFloatToScalar(adjustedX), SkFloatToScalar(adjustedY));
 
     RefPtr<SkShader> shader;
 
     // Bicubic filter is only applied to defer-decoded images, see
     // NativeImageSkia::draw for details.
-    bool useBicubicFilter = resampling == AwesomeResampling && isLazyDecoded;
+    bool useBicubicFilter = resampling == InterpolationHigh && isLazyDecoded;
 
-    if (resampling == AwesomeResampling && !useBicubicFilter) {
+    if (resampling == InterpolationHigh && !useBicubicFilter) {
         // Do nice resampling.
         float scaleX = destBitmapWidth / normSrcRect.width();
         float scaleY = destBitmapHeight / normSrcRect.height();
         SkRect scaledSrcRect;
 
         // Since we are resizing the bitmap, we need to remove the scale
         // applied to the pixels in the bitmap shader. This means we need
         // CTM * localMatrix to have identity scale. Since we
         // can't modify CTM (or the rectangle will be drawn in the wrong
         // place), we must set localMatrix's scale to the inverse of
@@ skipping 107 matching lines @@
 SkIRect NativeImageSkia::ImageResourceInfo::rectInSubset(const SkIRect& otherScaledImageSubset)
 {
     if (!scaledImageSubset.contains(otherScaledImageSubset))
         return SkIRect::MakeEmpty();
     SkIRect subsetRect = otherScaledImageSubset;
     subsetRect.offset(-scaledImageSubset.x(), -scaledImageSubset.y());
     return subsetRect;
 }
 
 } // namespace WebCore