cc: Update discardable image metadata generation to get PaintImages.

cc/raster/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/raster/image_hijack_canvas.h"
 
 #include "base/optional.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/paint/discardable_image_map.h"
 #include "cc/tiles/image_decode_cache.h"
@@ skipping 138 matching lines @@
   // forwarded to the raster canvas.
   SkCanvas::onDrawPicture(picture, matrix, paint);
 }
 
 void ImageHijackCanvas::onDrawImage(const SkImage* image,
                                     SkScalar x,
                                     SkScalar y,
                                     const SkPaint* paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawImage");
+  SkRect rect = SkRect::MakeXYWH(x, y, SkIntToScalar(image->width()),
+                                 SkIntToScalar(image->height()));
+  if (QuickRejectDraw(rect, paint))
+    return;
+
   if (!image->isLazyGenerated()) {
     DCHECK(!ShouldSkipImage(image));
     SkNWayCanvas::onDrawImage(image, x, y, paint);
     return;
   }
 
   if (ShouldSkipImage(image))
     return;
 
   SkMatrix ctm = getTotalMatrix();
@@ skipping 21 matching lines @@
     SkNWayCanvas::restore();
 }
 
 void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
                                         const SkRect* src,
                                         const SkRect& dst,
                                         const SkPaint* paint,
                                         SrcRectConstraint constraint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawImageRect");
+  if (QuickRejectDraw(dst, paint))
+    return;
+
   if (!image->isLazyGenerated()) {
     DCHECK(!ShouldSkipImage(image));
     SkNWayCanvas::onDrawImageRect(image, src, dst, paint, constraint);
     return;
   }
 
   if (ShouldSkipImage(image))
     return;
 
   SkRect src_storage;
@@ skipping 23 matching lines @@
         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().get(), &adjusted_src, dst,
                                 decoded_paint, constraint);
 }
 
 void ImageHijackCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawRect");
+  if (QuickRejectDraw(r, &paint))
+    return;
+
   if (ShouldSkipImageInPaint(paint))
     return;
 
   base::Optional<ScopedImagePaint> image_paint = ScopedImagePaint::TryCreate(
       image_decode_cache_, getTotalMatrix(), paint, target_color_space_);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawRect(r, paint);
     return;
   }
   SkNWayCanvas::onDrawRect(r, image_paint.value().paint());
 }
 
 void ImageHijackCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawPath");
+  if (QuickRejectDraw(path.getBounds(), &paint))
+    return;
+
   if (ShouldSkipImageInPaint(paint))
     return;
 
   base::Optional<ScopedImagePaint> image_paint = ScopedImagePaint::TryCreate(
       image_decode_cache_, getTotalMatrix(), paint, target_color_space_);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawPath(path, paint);
     return;
   }
   SkNWayCanvas::onDrawPath(path, image_paint.value().paint());
 }
 
 void ImageHijackCanvas::onDrawOval(const SkRect& r, const SkPaint& paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawOval");
+  if (QuickRejectDraw(r, &paint))
+    return;
+
   if (ShouldSkipImageInPaint(paint))
     return;
 
   base::Optional<ScopedImagePaint> image_paint = ScopedImagePaint::TryCreate(
       image_decode_cache_, getTotalMatrix(), paint, target_color_space_);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawOval(r, paint);
     return;
   }
   SkNWayCanvas::onDrawOval(r, image_paint.value().paint());
 }
 
 void ImageHijackCanvas::onDrawArc(const SkRect& r,
                                   SkScalar start_angle,
                                   SkScalar sweep_angle,
                                   bool use_center,
                                   const SkPaint& paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawArc");
+  if (QuickRejectDraw(r, &paint))
+    return;
+
   if (ShouldSkipImageInPaint(paint))
     return;
 
   base::Optional<ScopedImagePaint> image_paint = ScopedImagePaint::TryCreate(
       image_decode_cache_, getTotalMatrix(), paint, target_color_space_);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawArc(r, start_angle, sweep_angle, use_center, paint);
     return;
   }
   SkNWayCanvas::onDrawArc(r, start_angle, sweep_angle, use_center,
                           image_paint.value().paint());
 }
 
 void ImageHijackCanvas::onDrawRRect(const SkRRect& rr, const SkPaint& paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ImageHijackCanvas::onDrawRRect");
+  if (QuickRejectDraw(rr.rect(), &paint))
+    return;
+
   if (ShouldSkipImageInPaint(paint))
     return;
 
   base::Optional<ScopedImagePaint> image_paint = ScopedImagePaint::TryCreate(
       image_decode_cache_, getTotalMatrix(), paint, target_color_space_);
   if (!image_paint.has_value()) {
     SkNWayCanvas::onDrawRRect(rr, paint);
     return;
   }
   SkNWayCanvas::onDrawRRect(rr, image_paint.value().paint());
@@ skipping 14 matching lines @@
                "ImageHijackCanvas::ShouldSkipImage", "imageId",
                image->uniqueID(), "skip", skip);
   return skip;
 }
 
 bool ImageHijackCanvas::ShouldSkipImageInPaint(const SkPaint& paint) const {
   const SkImage* image = GetImageInPaint(paint);
   return image ? ShouldSkipImage(image) : false;
 }
 
+bool ImageHijackCanvas::QuickRejectDraw(const SkRect& rect,
+                                        const SkPaint* paint) const {
+  if (nullptr == paint || paint->canComputeFastBounds()) {
+    SkRect tmp = rect;
+    if (paint)
+      paint->computeFastBounds(tmp, &tmp);
+    return quickReject(tmp);
+  }
+
+  return false;
+}
+
 }  // namespace cc