cc: Add RasterSource::PlaybackSettings for finer control of raster.

cc/playback/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/raster_source.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 68 matching lines @@
 }
 
 RasterSource::~RasterSource() {
   // For MemoryDumpProvider deregistration to work correctly, this must happen
   // on the same thread that the RasterSource was created on.
   DCHECK(memory_dump_thread_checker_.CalledOnValidThread());
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
-void RasterSource::PlaybackToSharedCanvas(SkCanvas* raster_canvas,
-                                          const gfx::Rect& canvas_rect,
-                                          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();
-    ImageHijackCanvas canvas(info.width(), info.height(),
-                             image_decode_controller_);
-    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 RasterSource::RasterForAnalysis(skia::AnalysisCanvas* canvas,
-                                     const gfx::Rect& canvas_rect,
-                                     float contents_scale) const {
-  RasterCommon(canvas, canvas, canvas_rect, canvas_rect, contents_scale);
-}
-
 void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas,
                                     const gfx::Rect& canvas_bitmap_rect,
                                     const gfx::Rect& canvas_playback_rect,
                                     float contents_scale,
-                                    bool include_images) const {
-  PrepareForPlaybackToCanvas(raster_canvas, canvas_bitmap_rect,
-                             canvas_playback_rect, contents_scale);
+                                    const PlaybackSettings& settings) const {
+  if (!settings.playback_to_shared_canvas) {
+    PrepareForPlaybackToCanvas(raster_canvas, canvas_bitmap_rect,
+                               canvas_playback_rect, contents_scale);
+  }
 
-  if (!include_images) {
+  if (settings.skip_images) {
     SkipImageCanvas canvas(raster_canvas);
     RasterCommon(&canvas, nullptr, canvas_bitmap_rect, canvas_playback_rect,
                  contents_scale);
-  } else if (display_list_->MayHaveDiscardableImages()) {
+  } else if (settings.use_image_hijack_canvas &&
+             display_list_->MayHaveDiscardableImages()) {
     const SkImageInfo& info = raster_canvas->imageInfo();
     ImageHijackCanvas canvas(info.width(), info.height(),
                              image_decode_controller_);
     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 RasterSource::PrepareForPlaybackToCanvas(
     SkCanvas* canvas,
@@ skipping 130 matching lines @@
 bool RasterSource::PerformSolidColorAnalysis(const gfx::Rect& content_rect,
                                              float contents_scale,
                                              SkColor* color) const {
   TRACE_EVENT0("cc", "RasterSource::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect =
       gfx::ScaleToEnclosingRect(content_rect, 1.0f / contents_scale);
 
   layer_rect.Intersect(gfx::Rect(size_));
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
-  RasterForAnalysis(&canvas, layer_rect, 1.0f);
+  RasterCommon(&canvas, &canvas, layer_rect, layer_rect, 1.0f);
   return canvas.GetColorIfSolid(color);
 }
 
 void RasterSource::GetDiscardableImagesInRect(
     const gfx::Rect& layer_rect,
     float raster_scale,
     std::vector<DrawImage>* images) const {
   DCHECK_EQ(0u, images->size());
   display_list_->GetDiscardableImagesInRect(layer_rect, raster_scale, images);
 }
@@ skipping 70 matching lines @@
         base::StringPrintf("cc/display_lists/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;
 }
 
+RasterSource::PlaybackSettings::PlaybackSettings()
+    : playback_to_shared_canvas(false),
+      skip_images(false),
+      use_image_hijack_canvas(true) {}
+
 }  // namespace cc