Limit image filtering during scale animations

cc/playback/display_list_raster_source.cc

 // Copyright 2014 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/display_list_raster_source.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 29 matching lines @@
       requires_clear_(other->requires_clear_),
       can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       size_(other->size_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(false),
-      image_decode_controller_(nullptr) {
+      image_decode_controller_(nullptr),
+      image_scaling_optimization_(ImageScalingOptimization::Static) {
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "cc::DisplayListRasterSource",
         base::ThreadTaskRunnerHandle::Get());
   }
 }
 
@@ skipping 39 matching lines @@
     float contents_scale,
     bool include_images) const {
   // TODO(vmpstr): This can be improved by plumbing whether the tile itself has
   // discardable images. This way we would only pay for the hijack canvas if the
   // tile actually needed it.
   if (!include_images) {
     SkipImageCanvas canvas(raster_canvas);
     RasterCommon(&canvas, nullptr, canvas_rect, canvas_rect, contents_scale);
   } else if (display_list_->MayHaveDiscardableImages()) {
     const SkImageInfo& info = raster_canvas->imageInfo();
+    const SkFilterQuality max_quality =
+        image_scaling_optimization_ == ImageScalingOptimization::Static
+            ? kHigh_SkFilterQuality
+            : kMedium_SkFilterQuality;
     ImageHijackCanvas canvas(info.width(), info.height(),
-                             image_decode_controller_);
+                             image_decode_controller_, max_quality);
     canvas.addCanvas(raster_canvas);
 
     RasterCommon(&canvas, nullptr, canvas_rect, canvas_rect, contents_scale);
   } else {
     RasterCommon(raster_canvas, nullptr, canvas_rect, canvas_rect,
                  contents_scale);
   }
 }
 
 void DisplayListRasterSource::RasterForAnalysis(skia::AnalysisCanvas* canvas,
@@ skipping 10 matching lines @@
     bool include_images) const {
   PrepareForPlaybackToCanvas(raster_canvas, canvas_bitmap_rect,
                              canvas_playback_rect, contents_scale);
 
   if (!include_images) {
     SkipImageCanvas canvas(raster_canvas);
     RasterCommon(&canvas, nullptr, canvas_bitmap_rect, canvas_playback_rect,
                  contents_scale);
   } else if (display_list_->MayHaveDiscardableImages()) {
     const SkImageInfo& info = raster_canvas->imageInfo();
+    const SkFilterQuality max_quality =
+        image_scaling_optimization_ == ImageScalingOptimization::Static
+            ? kHigh_SkFilterQuality
+            : kMedium_SkFilterQuality;
     ImageHijackCanvas canvas(info.width(), info.height(),
-                             image_decode_controller_);
+                             image_decode_controller_, max_quality);
     canvas.addCanvas(raster_canvas);
     RasterCommon(&canvas, nullptr, canvas_bitmap_rect, canvas_playback_rect,
                  contents_scale);
   } else {
     RasterCommon(raster_canvas, nullptr, canvas_bitmap_rect,
                  canvas_playback_rect, contents_scale);
   }
 }
 
 void DisplayListRasterSource::PrepareForPlaybackToCanvas(
@@ skipping 210 matching lines @@
   return scoped_refptr<DisplayListRasterSource>(
       new DisplayListRasterSource(this, can_use_lcd_text));
 }
 
 void DisplayListRasterSource::SetImageDecodeController(
     ImageDecodeController* image_decode_controller) {
   DCHECK(image_decode_controller);
   image_decode_controller_ = image_decode_controller;
 }
 
+void DisplayListRasterSource::SetImageScalingOptimization(
+    ImageScalingOptimization opt) {
+  image_scaling_optimization_ = opt;
+}
+
 bool DisplayListRasterSource::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK(memory_dump_thread_checker_.CalledOnValidThread());
 
   uint64_t memory_usage = GetPictureMemoryUsage();
   if (memory_usage > 0) {
     std::string dump_name = base::StringPrintf(
         "cc/display_lists/display_list_raster_source_%p", this);
     base::trace_event::MemoryAllocatorDump* dump =
         pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                     memory_usage);
   }
   return true;
 }
 
 }  // namespace cc