Always use AwesomeResampling for lazy decoded 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 357 matching lines @@
 void NativeImageSkia::draw(GraphicsContext* context, const SkRect& srcRect, const SkRect& destRect, PassRefPtr<SkXfermode> compOp) const
 {
     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;
     if (context->isAccelerated()) {
         resampling = LinearResampling;
     } else if (context->printing()) {
         resampling = NoResampling;
+    } else if (isLazyDecoded) {
+        resampling = AwesomeResampling;
     } 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,
             SkScalarToFloat(srcRect.width()), SkScalarToFloat(srcRect.height()),
             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);
 
-    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;
 
     paint.setFilterLevel(convertToSkiaFilterLevel(useBicubicFilter, resampling));
 
     if (resampling == AwesomeResampling && !useBicubicFilter) {
         // Resample the image and then draw the result to canvas with bilinear
         // filtering.
@@ skipping 48 matching lines @@
 
     // Figure out what size the bitmap will be in the destination. The
     // destination rect is the bounds of the pattern, we need to use the
     // 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;
     if (context->isAccelerated() || context->printing())
         resampling = LinearResampling;
+    else if (isLazyDecoded)
+        resampling = AwesomeResampling;
     else
         resampling = computeResamplingMode(totalMatrix, normSrcRect.width(), normSrcRect.height(), destBitmapWidth, destBitmapHeight);
     resampling = limitResamplingMode(context, resampling);
 
     SkMatrix shaderTransform;
     RefPtr<SkShader> shader;
 
-    bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap());
     // Bicubic filter is only applied to defer-decoded images, see
     // NativeImageSkia::draw for details.
     bool useBicubicFilter = resampling == AwesomeResampling && isLazyDecoded;
 
     if (resampling == AwesomeResampling && !useBicubicFilter) {
         // Do nice resampling.
         float scaleX = destBitmapWidth / normSrcRect.width();
         float scaleY = destBitmapHeight / normSrcRect.height();
         SkRect scaledSrcRect;
 
@@ skipping 121 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