cc: Refactor SkipImageCanvas and create it during playback.

This patch moves SkipImageCanvas into a separate file in the same
directory as ImageHijackCanvas and also moves the creation of
SkipImageCanvas to raster source playback (the same place as
ImageHijackCanvas is created).

BUG=594679
R=enne, ericrk
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1799883002

Cr-Commit-Position: refs/heads/master@{#381101}

14 files changed, 119 insertions, 67 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 38006a7..f5eacc1 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -309,6 +309,8 @@ component("cc") {
     "playback/image_hijack_canvas.h",
     "playback/largest_display_item.cc",
     "playback/largest_display_item.h",
+    "playback/skip_image_canvas.cc",
+    "playback/skip_image_canvas.h",
     "playback/transform_display_item.cc",
     "playback/transform_display_item.h",
     "proto/base_conversions.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 7b54509..3600470 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -371,6 +371,8 @@
         'playback/image_hijack_canvas.h',
         'playback/largest_display_item.cc',
         'playback/largest_display_item.h',
+        'playback/skip_image_canvas.cc',
+        'playback/skip_image_canvas.h',
         'playback/transform_display_item.cc',
         'playback/transform_display_item.h',
         'proto/base_conversions.cc',
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index 47cc016..d2999c5 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -53,8 +53,9 @@ void RunBenchmark(DisplayListRasterSource* raster_source,
                                                     content_rect.height()));
       SkCanvas canvas(bitmap);
 
+      const bool include_images = true;
       raster_source->PlaybackToCanvas(&canvas, content_rect, content_rect,
-                                      contents_scale);
+                                      contents_scale, include_images);
 
       timer.NextLap();
     } while (!timer.HasTimeLimitExpired());
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 90800f2..fd505af 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -459,8 +459,9 @@ TEST_F(PictureLayerImplTest, TileGridAlignment) {
   std::vector<SkRect>::const_iterator rect_iter = rects.begin();
   for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
     MockCanvas mock_canvas(1000, 1000);
+    const bool include_images = true;
     updated_active_raster_source->PlaybackToSharedCanvas(
-        &mock_canvas, (*tile_iter)->content_rect(), 1.0f);
+        &mock_canvas, (*tile_iter)->content_rect(), 1.0f, include_images);
 
     // This test verifies that when drawing the contents of a specific tile
     // at content scale 1.0, the playback canvas never receives content from
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index a2a7c49..12165b1 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -366,18 +366,24 @@ void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
 
   TRACE_EVENT0("cc", "SoftwareRenderer::DrawPictureQuad");
 
+  const bool include_images = true;
   if (needs_transparency || disable_image_filtering) {
     // TODO(aelias): This isn't correct in all cases. We should detect these
     // cases and fall back to a persistent bitmap backing
     // (http://crbug.com/280374).
+    // TODO(vmpstr): Fold this canvas into playback and have raster source
+    // accept a set of settings on playback that will determine which canvas to
+    // apply. (http://crbug.com/594679)
     skia::OpacityFilterCanvas filtered_canvas(current_canvas_,
                                               quad->shared_quad_state->opacity,
                                               disable_image_filtering);
     quad->raster_source->PlaybackToSharedCanvas(
-        &filtered_canvas, quad->content_rect, quad->contents_scale);
+        &filtered_canvas, quad->content_rect, quad->contents_scale,
+        include_images);
   } else {
     quad->raster_source->PlaybackToSharedCanvas(
-        current_canvas_, quad->content_rect, quad->contents_scale);
+        current_canvas_, quad->content_rect, quad->contents_scale,
+        include_images);
   }
 }
 
diff --git a/cc/playback/display_list_raster_source.cc b/cc/playback/display_list_raster_source.cc
index fe707ec..a6d2c84 100644
--- a/cc/playback/display_list_raster_source.cc
+++ b/cc/playback/display_list_raster_source.cc
@@ -14,6 +14,7 @@
 #include "cc/debug/debug_colors.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/image_hijack_canvas.h"
+#include "cc/playback/skip_image_canvas.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
@@ -96,11 +97,15 @@ DisplayListRasterSource::~DisplayListRasterSource() {
 void DisplayListRasterSource::PlaybackToSharedCanvas(
     SkCanvas* raster_canvas,
     const gfx::Rect& canvas_rect,
-    float contents_scale) const {
+    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 (display_list_->MayHaveDiscardableImages()) {
+  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_);
@@ -123,11 +128,16 @@ void DisplayListRasterSource::PlaybackToCanvas(
     SkCanvas* raster_canvas,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
-    float contents_scale) const {
+    float contents_scale,
+    bool include_images) const {
   PrepareForPlaybackToCanvas(raster_canvas, canvas_bitmap_rect,
                              canvas_playback_rect, contents_scale);
 
-  if (display_list_->MayHaveDiscardableImages()) {
+  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();
     ImageHijackCanvas canvas(info.width(), info.height(),
                              image_decode_controller_);
diff --git a/cc/playback/display_list_raster_source.h b/cc/playback/display_list_raster_source.h
index 5599f59a..361019c 100644
--- a/cc/playback/display_list_raster_source.h
+++ b/cc/playback/display_list_raster_source.h
@@ -48,14 +48,16 @@ class CC_EXPORT DisplayListRasterSource
   virtual void PlaybackToCanvas(SkCanvas* canvas,
                                 const gfx::Rect& canvas_bitmap_rect,
                                 const gfx::Rect& canvas_playback_rect,
-                                float contents_scale) const;
+                                float contents_scale,
+                                bool include_images) const;
 
   // Similar to above, except that the canvas passed here can (or was already)
   // rasterized into by another raster source. That is, it is not safe to clear
   // the canvas or discard its underlying memory.
   void PlaybackToSharedCanvas(SkCanvas* canvas,
                               const gfx::Rect& canvas_rect,
-                              float contents_scale) const;
+                              float contents_scale,
+                              bool include_images) const;
 
   // Returns whether the given rect at given scale is of solid color in
   // this raster source, as well as the solid color value.
diff --git a/cc/playback/display_list_raster_source_unittest.cc b/cc/playback/display_list_raster_source_unittest.cc
index 2cf6f06..ffaf892 100644
--- a/cc/playback/display_list_raster_source_unittest.cc
+++ b/cc/playback/display_list_raster_source_unittest.cc
@@ -290,8 +290,9 @@ TEST(DisplayListRasterSourceTest, RasterFullContents) {
       SkCanvas canvas(bitmap);
       canvas.clear(SK_ColorTRANSPARENT);
 
+      const bool include_images = true;
       raster->PlaybackToCanvas(&canvas, canvas_rect, canvas_rect,
-                               contents_scale);
+                               contents_scale, include_images);
 
       SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
       int num_pixels = bitmap.width() * bitmap.height();
@@ -342,8 +343,9 @@ TEST(DisplayListRasterSourceTest, RasterPartialContents) {
   // Playback the full rect which should make everything white.
   gfx::Rect raster_full_rect(content_bounds);
   gfx::Rect playback_rect(content_bounds);
+  const bool include_images = true;
   raster->PlaybackToCanvas(&canvas, raster_full_rect, playback_rect,
-                           contents_scale);
+                           contents_scale, include_images);
 
   {
     SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
@@ -374,7 +376,7 @@ TEST(DisplayListRasterSourceTest, RasterPartialContents) {
   // that touches the edge pixels of the recording.
   playback_rect.Inset(1, 2, 0, 1);
   raster->PlaybackToCanvas(&canvas, raster_full_rect, playback_rect,
-                           contents_scale);
+                           contents_scale, include_images);
 
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
   int num_black = 0;
@@ -438,8 +440,9 @@ TEST(DisplayListRasterSourceTest, RasterPartialClear) {
   // Playback the full rect which should make everything light gray (alpha=10).
   gfx::Rect raster_full_rect(content_bounds);
   gfx::Rect playback_rect(content_bounds);
+  const bool include_images = true;
   raster->PlaybackToCanvas(&canvas, raster_full_rect, playback_rect,
-                           contents_scale);
+                           contents_scale, include_images);
 
   {
     SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
@@ -478,7 +481,7 @@ TEST(DisplayListRasterSourceTest, RasterPartialClear) {
   playback_rect =
       gfx::Rect(gfx::ScaleToCeiledSize(partial_bounds, contents_scale));
   raster->PlaybackToCanvas(&canvas, raster_full_rect, playback_rect,
-                           contents_scale);
+                           contents_scale, include_images);
 
   // Test that the whole playback_rect was cleared and repainted with new alpha.
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
@@ -518,7 +521,9 @@ TEST(DisplayListRasterSourceTest, RasterContentsTransparent) {
   bitmap.allocN32Pixels(canvas_rect.width(), canvas_rect.height());
   SkCanvas canvas(bitmap);
 
-  raster->PlaybackToCanvas(&canvas, canvas_rect, canvas_rect, contents_scale);
+  const bool include_images = true;
+  raster->PlaybackToCanvas(&canvas, canvas_rect, canvas_rect, contents_scale,
+                           include_images);
 
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
   int num_pixels = bitmap.width() * bitmap.height();
diff --git a/cc/playback/skip_image_canvas.cc b/cc/playback/skip_image_canvas.cc
new file mode 100644
index 0000000..badaf10
--- /dev/null
+++ b/cc/playback/skip_image_canvas.cc
@@ -0,0 +1,33 @@
+// 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/skip_image_canvas.h"
+
+#include "third_party/skia/include/core/SkShader.h"
+
+namespace cc {
+
+SkipImageCanvas::SkipImageCanvas(SkCanvas* canvas)
+    : SkPaintFilterCanvas(canvas) {}
+
+bool SkipImageCanvas::onFilter(SkTCopyOnFirstWrite<SkPaint>* paint,
+                               Type type) const {
+  if (type == kBitmap_Type)
+    return false;
+
+  SkShader* shader = (*paint) ? (*paint)->getShader() : nullptr;
+  return !shader || !shader->isABitmap();
+}
+
+void SkipImageCanvas::onDrawPicture(const SkPicture* picture,
+                                    const SkMatrix* matrix,
+                                    const SkPaint* paint) {
+  SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
+
+  // To filter nested draws, we must unfurl pictures at this stage.
+  if (onFilter(&filteredPaint, kPicture_Type))
+    SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
+}
+
+}  // namespace cc
diff --git a/cc/playback/skip_image_canvas.h b/cc/playback/skip_image_canvas.h
new file mode 100644
index 0000000..67206b7
--- /dev/null
+++ b/cc/playback/skip_image_canvas.h
@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef CC_PLAYBACK_SKIP_IMAGE_CANVAS_H_
+#define CC_PLAYBACK_SKIP_IMAGE_CANVAS_H_
+
+#include "third_party/skia/include/utils/SkPaintFilterCanvas.h"
+
+namespace cc {
+
+class SkipImageCanvas : public SkPaintFilterCanvas {
+ public:
+  explicit SkipImageCanvas(SkCanvas* canvas);
+
+ private:
+  bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const override;
+
+  void onDrawPicture(const SkPicture* picture,
+                     const SkMatrix* matrix,
+                     const SkPaint* paint) override;
+};
+
+}  // namespace cc
+
+#endif  // CC_PLAYBACK_SKIP_IMAGE_CANVAS_H_
diff --git a/cc/raster/gpu_rasterizer.cc b/cc/raster/gpu_rasterizer.cc
index 2dcd8e0..7e8c131 100644
--- a/cc/raster/gpu_rasterizer.cc
+++ b/cc/raster/gpu_rasterizer.cc
@@ -51,8 +51,9 @@ void GpuRasterizer::RasterizeSource(
   skia::RefPtr<SkCanvas> canvas = skia::SharePtr(
       recorder.beginRecording(size.width(), size.height(), NULL, flags));
   canvas->save();
+  const bool include_images = true;
   raster_source->PlaybackToCanvas(canvas.get(), raster_full_rect, playback_rect,
-                                  scale);
+                                  scale, include_images);
   canvas->restore();
   skia::RefPtr<SkPicture> picture =
       skia::AdoptRef(recorder.endRecordingAsPicture());
diff --git a/cc/raster/tile_task_worker_pool.cc b/cc/raster/tile_task_worker_pool.cc
index 09051cf..263720d 100644
--- a/cc/raster/tile_task_worker_pool.cc
+++ b/cc/raster/tile_task_worker_pool.cc
@@ -12,7 +12,6 @@
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
-#include "third_party/skia/include/utils/SkPaintFilterCanvas.h"
 
 namespace cc {
 
@@ -58,45 +57,6 @@ bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
   return false;
 }
 
-class SkipImageCanvas : public SkPaintFilterCanvas {
- public:
-  explicit SkipImageCanvas(SkCanvas* canvas) : SkPaintFilterCanvas(canvas) {}
-
-  bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const override {
-    if (type == kBitmap_Type)
-      return false;
-
-    SkShader* shader = (*paint) ? (*paint)->getShader() : nullptr;
-    return !shader || !shader->isABitmap();
-  }
-
-  void onDrawPicture(const SkPicture* picture,
-                     const SkMatrix* matrix,
-                     const SkPaint* paint) override {
-    SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
-
-    // To filter nested draws, we must unfurl pictures at this stage.
-    if (onFilter(&filteredPaint, kPicture_Type))
-      SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
-  }
-};
-
-class AutoSkipImageCanvas {
- public:
-  AutoSkipImageCanvas(SkCanvas* canvas, bool include_images) : canvas_(canvas) {
-    if (!include_images) {
-      skip_image_canvas_ = skia::AdoptRef(new SkipImageCanvas(canvas));
-      canvas_ = skip_image_canvas_.get();
-    }
-  }
-
-  operator SkCanvas*() { return canvas_; }
-
- private:
-  skia::RefPtr<SkCanvas> skip_image_canvas_;
-  SkCanvas* canvas_;
-};
-
 }  // anonymous namespace
 
 // static
@@ -134,20 +94,20 @@ void TileTaskWorkerPool::PlaybackToMemory(
     case BGRA_8888: {
       skia::RefPtr<SkSurface> surface = skia::AdoptRef(
           SkSurface::NewRasterDirect(info, memory, stride, &surface_props));
-      AutoSkipImageCanvas canvas(surface->getCanvas(), include_images);
-      raster_source->PlaybackToCanvas(canvas, canvas_bitmap_rect,
-                                      canvas_playback_rect, scale);
+      raster_source->PlaybackToCanvas(surface->getCanvas(), canvas_bitmap_rect,
+                                      canvas_playback_rect, scale,
+                                      include_images);
       return;
     }
     case RGBA_4444:
     case ETC1: {
       skia::RefPtr<SkSurface> surface =
           skia::AdoptRef(SkSurface::NewRaster(info, &surface_props));
-      AutoSkipImageCanvas canvas(surface->getCanvas(), include_images);
       // TODO(reveman): Improve partial raster support by reducing the size of
       // playback rect passed to PlaybackToCanvas. crbug.com/519070
-      raster_source->PlaybackToCanvas(canvas, canvas_bitmap_rect,
-                                      canvas_bitmap_rect, scale);
+      raster_source->PlaybackToCanvas(surface->getCanvas(), canvas_bitmap_rect,
+                                      canvas_bitmap_rect, scale,
+                                      include_images);
 
       if (format == ETC1) {
         TRACE_EVENT0("cc",
diff --git a/cc/test/fake_display_list_raster_source.cc b/cc/test/fake_display_list_raster_source.cc
index 163559b..8acca50 100644
--- a/cc/test/fake_display_list_raster_source.cc
+++ b/cc/test/fake_display_list_raster_source.cc
@@ -148,11 +148,13 @@ void FakeDisplayListRasterSource::PlaybackToCanvas(
     SkCanvas* canvas,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
-    float contents_scale) const {
+    float contents_scale,
+    bool include_images) const {
   if (playback_allowed_event_)
     playback_allowed_event_->Wait();
-  DisplayListRasterSource::PlaybackToCanvas(
-      canvas, canvas_bitmap_rect, canvas_playback_rect, contents_scale);
+  DisplayListRasterSource::PlaybackToCanvas(canvas, canvas_bitmap_rect,
+                                            canvas_playback_rect,
+                                            contents_scale, include_images);
 }
 
 }  // namespace cc
diff --git a/cc/test/fake_display_list_raster_source.h b/cc/test/fake_display_list_raster_source.h
index 8936fbe..1d63fe6 100644
--- a/cc/test/fake_display_list_raster_source.h
+++ b/cc/test/fake_display_list_raster_source.h
@@ -41,7 +41,8 @@ class FakeDisplayListRasterSource : public DisplayListRasterSource {
   void PlaybackToCanvas(SkCanvas* canvas,
                         const gfx::Rect& canvas_bitmap_rect,
                         const gfx::Rect& canvas_playback_rect,
-                        float contents_scale) const override;
+                        float contents_scale,
+                        bool include_images) const override;
 
  protected:
   FakeDisplayListRasterSource(