Implement InterpolationMedium to filter animated images

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 126 matching lines @@
 
     return LinearResampling;
 }
 
 static ResamplingMode limitResamplingMode(GraphicsContext* context, ResamplingMode resampling)
 {
     switch (context->imageInterpolationQuality()) {
     case InterpolationNone:
         return NoResampling;
     case InterpolationMedium:
-        // For now we treat InterpolationMedium and InterpolationLow the same.
+        if (resampling == AwesomeResampling)
+            return LinearWithMipmapsResampling;
+        break;
     case InterpolationLow:
-        if (resampling == AwesomeResampling)
+        if (resampling == AwesomeResampling || resampling == LinearWithMipmapsResampling)
             return LinearResampling;
         break;
     case InterpolationHigh:
-    case InterpolationDefault:
         break;
     }
 
     return resampling;
 }
 
+static SkPaint::FilterLevel convertToSkiaFilterLevel(bool useBicubicFilter, ResamplingMode resampling)
+{
+    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
+    // a manual high quality resampling before drawing to Skia.
+    case AwesomeResampling:
+    default:
+        return SkPaint::kNone_FilterLevel;
+    }
+}
+
 // 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())
 // approximateScaleX = scaledImageWidth / imageRect.width()
 //
@@ skipping 176 matching lines @@
             SkScalarToFloat(destRectTarget.width()), SkScalarToFloat(destRectTarget.height()));
     }
 
     if (resampling == NoResampling) {
         // 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;
     }
     resampling = limitResamplingMode(context, resampling);
-    paint.setFilterBitmap(resampling == LinearResampling);
 
     bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap());
     // 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;
 
-    if (useBicubicFilter)
-        paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
+    paint.setFilterLevel(convertToSkiaFilterLevel(useBicubicFilter, resampling));
 
     if (resampling == AwesomeResampling && !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.
@@ skipping 113 matching lines @@
     // a shifted image, it will shift it from there using the shaderTransform.
     float adjustedX = phase.x() + normSrcRect.x() * scale.width();
     float adjustedY = phase.y() + normSrcRect.y() * scale.height();
     shaderTransform.postTranslate(SkFloatToScalar(adjustedX), SkFloatToScalar(adjustedY));
     shader->setLocalMatrix(shaderTransform);
 
     SkPaint paint;
     paint.setShader(shader.get());
     paint.setXfermode(WebCoreCompositeToSkiaComposite(compositeOp, blendMode).get());
     paint.setColorFilter(context->colorFilter());
+    paint.setFilterLevel(convertToSkiaFilterLevel(useBicubicFilter, resampling));
 
-    paint.setFilterBitmap(resampling == LinearResampling);
-    if (useBicubicFilter)
-        paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
     if (isLazyDecoded)
         PlatformInstrumentation::didDrawLazyPixelRef(bitmap().getGenerationID());
 
     context->drawRect(destRect, paint);
 }
 
 bool NativeImageSkia::shouldCacheResampling(const SkISize& scaledImageSize, const SkIRect& scaledImageSubset) const
 {
     // Check whether the requested dimensions match previous request.
     bool matchesPreviousRequest = m_cachedImageInfo.isEqual(scaledImageSize, scaledImageSubset);
@@ skipping 59 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