cc: Keep PaintImage in DrawImage.

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"
 #include "third_party/skia/include/core/SkPath.h"
 
 namespace cc {
 namespace {
 
+// Using a single id for images captured using the hijack canvas.
+PaintImage::Id s_canvas_paint_image_id = PaintImage::GetNextId();

[vmpstr, 2017/05/16 17:43:27]

My concern is just initializing globals using function calls that rely on
globals. Is there another place you can put this?

[Khushal, 2017/05/16 21:29:12]

Oh, I'm sorry. Forgot to remove this. Its not necessary anymore since we use the
kUnknownStableId for all these cases.

+
 SkIRect RoundOutRect(const SkRect& rect) {
   SkIRect result;
   rect.roundOut(&result);
   return result;
 }
 
 class ScopedDecodedImageLock {
  public:
   ScopedDecodedImageLock(ImageDecodeCache* image_decode_cache,
-                         sk_sp<const SkImage> image,
+                         sk_sp<SkImage> image,
                          const SkRect& src_rect,
                          const SkMatrix& matrix,
                          const SkPaint* paint,
                          const gfx::ColorSpace& target_color_space)
       : image_decode_cache_(image_decode_cache),
-        draw_image_(std::move(image),
+        // TODO(khushalsagar): Using the wrong id should not be necessary once
+        // the hijack canvas is eliminated.
+        draw_image_(PaintImage(PaintImage::kWrongStableId, std::move(image)),
                     RoundOutRect(src_rect),
                     paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
                     matrix,
                     target_color_space),
         decoded_draw_image_(
             image_decode_cache_->GetDecodedImageForDraw(draw_image_)) {
     DCHECK(draw_image_.image()->isLazyGenerated());
     if (paint) {
       decoded_paint_ = *paint;
       decoded_paint_->setFilterQuality(decoded_draw_image_.filter_quality());
@@ skipping 84 matching lines @@
 const SkImage* GetImageInPaint(const SkPaint& paint) {
   SkShader* shader = paint.getShader();
   return shader ? shader->isAImage(nullptr, nullptr) : nullptr;
 }
 
 }  // namespace
 
 ImageHijackCanvas::ImageHijackCanvas(int width,
                                      int height,
                                      ImageDecodeCache* image_decode_cache,
-                                     const ImageIdFlatSet* images_to_skip,
+                                     const SkImageIdFlatSet* images_to_skip,
                                      const gfx::ColorSpace& target_color_space)
     : SkNWayCanvas(width, height),
       image_decode_cache_(image_decode_cache),
       images_to_skip_(images_to_skip),
       target_color_space_(target_color_space) {}
 
 void ImageHijackCanvas::onDrawPicture(const SkPicture* picture,
                                       const SkMatrix* matrix,
                                       const SkPaint* paint) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 19 matching lines @@
     SkNWayCanvas::onDrawImage(image, x, y, paint);
     return;
   }
 
   if (ShouldSkipImage(image))
     return;
 
   SkMatrix ctm = getTotalMatrix();
 
   ScopedDecodedImageLock scoped_lock(
-      image_decode_cache_, sk_ref_sp(image),
+      image_decode_cache_, sk_ref_sp(const_cast<SkImage*>(image)),
       SkRect::MakeIWH(image->width(), image->height()), ctm, paint,
       target_color_space_);
   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()));
   DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().height()));
   const SkPaint* decoded_paint = scoped_lock.decoded_paint();
 
@@ skipping 29 matching lines @@
 
   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),
+  ScopedDecodedImageLock scoped_lock(image_decode_cache_,
+                                     sk_ref_sp(const_cast<SkImage*>(image)),
                                      *src, matrix, paint, target_color_space_);
   const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
   if (!decoded_image.image())
     return;
 
   const SkPaint* decoded_paint = scoped_lock.decoded_paint();
 
   SkRect adjusted_src =
       src->makeOffset(decoded_image.src_rect_offset().width(),
                       decoded_image.src_rect_offset().height());
@@ skipping 131 matching lines @@
     SkRect tmp = rect;
     if (paint)
       paint->computeFastBounds(tmp, &tmp);
     return quickReject(tmp);
   }
 
   return false;
 }
 
 }  // namespace cc