Limit image filtering during scale animations

cc/playback/image_hijack_canvas.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/playback/image_hijack_canvas.h"
 
 #include "cc/playback/discardable_image_map.h"
 #include "cc/tiles/image_decode_controller.h"
 #include "third_party/skia/include/core/SkTLazy.h"
 
 namespace cc {
 namespace {
 
 SkIRect RoundOutRect(const SkRect& rect) {
   SkIRect result;
   rect.roundOut(&result);
   return result;
 }
 
 class ScopedDecodedImageLock {
  public:
   ScopedDecodedImageLock(ImageDecodeController* image_decode_controller,
                          const SkImage* image,
                          const SkRect& src_rect,
                          const SkMatrix& matrix,
-                         const SkPaint* paint)
+                         const SkPaint* paint,
+                         SkFilterQuality max_quality)
       : image_decode_controller_(image_decode_controller),
         draw_image_(image,
                     RoundOutRect(src_rect),
-                    paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
+                    paint ? std::min(max_quality, paint->getFilterQuality())
+                          : kNone_SkFilterQuality,
                     matrix),
         decoded_draw_image_(
             image_decode_controller_->GetDecodedImageForDraw(draw_image_)) {
     DCHECK(image->isLazyGenerated());
     if (paint)
       decoded_paint_.set(*paint)->setFilterQuality(
           decoded_draw_image_.filter_quality());
   }
 
   ~ScopedDecodedImageLock() {
@@ skipping 10 matching lines @@
   DecodedDrawImage decoded_draw_image_;
   // TODO(fmalita): use base::Optional when it becomes available
   SkTLazy<SkPaint> decoded_paint_;
 };
 
 }  // namespace
 
 ImageHijackCanvas::ImageHijackCanvas(
     int width,
     int height,
-    ImageDecodeController* image_decode_controller)
+    ImageDecodeController* image_decode_controller,
+    SkFilterQuality max_quality)
     : SkNWayCanvas(width, height),
-      image_decode_controller_(image_decode_controller) {}
+      image_decode_controller_(image_decode_controller),
+      max_quality_(max_quality) {}
 
 void ImageHijackCanvas::onDrawPicture(const SkPicture* picture,
                                       const SkMatrix* matrix,
                                       const SkPaint* paint) {
   // Ensure that pictures are unpacked by this canvas, instead of being
   // forwarded to the raster canvas.
   SkCanvas::onDrawPicture(picture, matrix, paint);
 }
 
 void ImageHijackCanvas::onDrawImage(const SkImage* image,
                                     SkScalar x,
                                     SkScalar y,
                                     const SkPaint* paint) {
   if (!image->isLazyGenerated()) {
     SkNWayCanvas::onDrawImage(image, x, y, paint);
     return;
   }
 
   SkMatrix ctm = getTotalMatrix();
 
   ScopedDecodedImageLock scoped_lock(
       image_decode_controller_, image,
-      SkRect::MakeIWH(image->width(), image->height()), ctm, paint);
+      SkRect::MakeIWH(image->width(), image->height()), ctm, paint,
+      max_quality_);
   const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
   if (!decoded_image.image())
     return;
 
   DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().width()));
   DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().height()));
   const SkPaint* decoded_paint = scoped_lock.decoded_paint();
 
   bool need_scale = !decoded_image.is_scale_adjustment_identity();
   if (need_scale) {
@@ skipping 19 matching lines @@
   SkRect src_storage;
   if (!src) {
     src_storage = SkRect::MakeIWH(image->width(), image->height());
     src = &src_storage;
   }
   SkMatrix matrix;
   matrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
   matrix.postConcat(getTotalMatrix());
 
   ScopedDecodedImageLock scoped_lock(image_decode_controller_, image, *src,
-                                     matrix, paint);
+                                     matrix, paint, max_quality_);
   const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
   if (!decoded_image.image())
     return;
 
   const SkPaint* decoded_paint = scoped_lock.decoded_paint();
 
   SkRect adjusted_src =
       src->makeOffset(decoded_image.src_rect_offset().width(),
                       decoded_image.src_rect_offset().height());
   if (!decoded_image.is_scale_adjustment_identity()) {
     float x_scale = decoded_image.scale_adjustment().width();
     float y_scale = decoded_image.scale_adjustment().height();
     adjusted_src = SkRect::MakeXYWH(
         adjusted_src.x() * x_scale, adjusted_src.y() * y_scale,
         adjusted_src.width() * x_scale, adjusted_src.height() * y_scale);
   }
   SkNWayCanvas::onDrawImageRect(decoded_image.image(), &adjusted_src, dst,
                                 decoded_paint, constraint);
 }
 
 void ImageHijackCanvas::onDrawImageNine(const SkImage* image,
                                         const SkIRect& center,
                                         const SkRect& dst,
                                         const SkPaint* paint) {
   // No cc embedder issues image nine calls.
   NOTREACHED();
 }
 
 }  // namespace cc