cc: Add checker-imaging support to TileManager.

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 "base/optional.h"
 #include "cc/playback/discardable_image_map.h"
 #include "cc/tiles/image_decode_cache.h"
 #include "third_party/skia/include/core/SkPath.h"
@@ skipping 102 matching lines @@
  private:
   ScopedImagePaint(ScopedDecodedImageLock lock, SkPaint paint)
       : lock_(std::move(lock)), paint_(std::move(paint)) {}
 
   ScopedDecodedImageLock lock_;
   SkPaint paint_;
 };
 
 }  // namespace
 
-ImageHijackCanvas::ImageHijackCanvas(int width,
-                                     int height,
-                                     ImageDecodeCache* image_decode_cache)
-    : SkNWayCanvas(width, height), image_decode_cache_(image_decode_cache) {}
+ImageHijackCanvas::ImageHijackCanvas(
+    int width,
+    int height,
+    ImageDecodeCache* image_decode_cache,
+    const std::unordered_set<ImageId>* images_to_skip)
+    : SkNWayCanvas(width, height),
+      image_decode_cache_(image_decode_cache),
+      images_to_skip_(images_to_skip) {}
 
 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()) {
+    DCHECK(!ShouldSkipImage(image));
     SkNWayCanvas::onDrawImage(image, x, y, paint);
     return;
   }
 
+  if (ShouldSkipImage(image))
+    return;
+
   SkMatrix ctm = getTotalMatrix();
 
   ScopedDecodedImageLock scoped_lock(
       image_decode_cache_, sk_ref_sp(image),
       SkRect::MakeIWH(image->width(), image->height()), ctm, paint);
   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()));
@@ skipping 10 matching lines @@
   if (need_scale)
     SkNWayCanvas::restore();
 }
 
 void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
                                         const SkRect* src,
                                         const SkRect& dst,
                                         const SkPaint* paint,
                                         SrcRectConstraint constraint) {
   if (!image->isLazyGenerated()) {
+    DCHECK(!ShouldSkipImage(image));
     SkNWayCanvas::onDrawImageRect(image, src, dst, paint, constraint);
     return;
   }
 
+  if (ShouldSkipImage(image))
+    return;
+
   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_cache_, sk_ref_sp(image),
@@ skipping 18 matching lines @@
                                 decoded_paint, constraint);
 }
 
 void ImageHijackCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) {
   base::Optional<ScopedImagePaint> image_paint =
       ScopedImagePaint::TryCreate(image_decode_cache_, getTotalMatrix(), paint);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawRect(r, paint);
     return;
   }
   SkNWayCanvas::onDrawRect(r, image_paint.value().paint());

[vmpstr, 2017/02/10 19:25:42]

There's a case here that is a bit awkward. Specifically, I think you can have
the same image as a background image and an img tag at the same time. Whereas
you checker the img tags in this patch, this (the background) path will cause a
decode and block raster.

[Khushal, 2017/02/10 22:09:19]

Thanks for pointing this out. I've added a check for skipping the op if the
paint has an image. Still won't work for images we are not capturing
(SkPictureShaders..).

 }
 
 void ImageHijackCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
   base::Optional<ScopedImagePaint> image_paint =
       ScopedImagePaint::TryCreate(image_decode_cache_, getTotalMatrix(), paint);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawPath(path, paint);
     return;
   }
   SkNWayCanvas::onDrawPath(path, image_paint.value().paint());
@@ skipping 35 matching lines @@
 }
 
 void ImageHijackCanvas::onDrawImageNine(const SkImage* image,
                                         const SkIRect& center,
                                         const SkRect& dst,
                                         const SkPaint* paint) {
   // No cc embedder issues image nine calls.
   NOTREACHED();
 }
 
+bool ImageHijackCanvas::ShouldSkipImage(const SkImage* image) {
+  return images_to_skip_->find(image->uniqueID()) != images_to_skip_->end();
+}
+
 }  // namespace cc