Add stable id to PaintImage.

third_party/WebKit/Source/platform/graphics/Image.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 34 matching lines @@
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "third_party/skia/include/core/SkImage.h"
 
 #include <math.h>
 #include <tuple>
 
 namespace blink {
 
 Image::Image(ImageObserver* observer)
-    : image_observer_disabled_(false), image_observer_(observer) {}
+    : image_observer_disabled_(false),
+      image_observer_(observer),
+      stable_image_id_(PaintImage::GetNextId()) {}

[chrishtr, 2017/05/10 22:56:11]

How about making Image the class which creates its own id,
instead of delegating to PaintImage?

[vmpstr, 2017/05/10 23:21:47]

Hm.. You mean have the id generation happen from Image? This id needs to be
unique for any paint image created (unless of course it explicitly references
the same logical image). I'm not sure how to guarantee that without actually
asking PaintImage to get the next id... This is kind of like an Image that
creates its own id, except it just uses PaintImage as the generator.

Do you have a specific concern about this breaking something?

 
 Image::~Image() {}
 
 Image* Image::NullImage() {
   DCHECK(IsMainThread());
   DEFINE_STATIC_REF(Image, null_image, (BitmapImage::Create()));
   return null_image;
 }
 
 PassRefPtr<Image> Image::LoadPlatformResource(const char* name) {
@@ skipping 224 matching lines @@
                             SkFloatToScalar(adjusted_y));
 
   // Because no resizing occurred, the shader transform should be
   // set to the pattern's transform, which just includes scale.
   local_matrix.preScale(scale.Width(), scale.Height());
 
   // Fetch this now as subsetting may swap the image.
   auto image_id = image.sk_image()->uniqueID();
 
   image =
-      PaintImage(image.sk_image()->makeSubset(EnclosingIntRect(norm_src_rect)),
+      PaintImage(stable_image_id_,
+                 image.sk_image()->makeSubset(EnclosingIntRect(norm_src_rect)),
                  image.animation_type(), image.completion_state());
   if (!image)
     return;
 
   const FloatSize tile_size(
       image.sk_image()->width() * scale.Width() + repeat_spacing.Width(),
       image.sk_image()->height() * scale.Height() + repeat_spacing.Height());
   const auto tmx = ComputeTileMode(dest_rect.X(), dest_rect.MaxX(), adjusted_x,
                                    adjusted_x + tile_size.Width());
   const auto tmy = ComputeTileMode(dest_rect.Y(), dest_rect.MaxY(), adjusted_y,
@@ skipping 27 matching lines @@
 
   return image.Release();
 }
 
 PaintImage Image::PaintImageForCurrentFrame() {
   auto animation_type = MaybeAnimated() ? PaintImage::AnimationType::ANIMATED
                                         : PaintImage::AnimationType::STATIC;
   auto completion_state = CurrentFrameIsComplete()
                               ? PaintImage::CompletionState::DONE
                               : PaintImage::CompletionState::PARTIALLY_DONE;
-  return PaintImage(ImageForCurrentFrame(), animation_type, completion_state);
+  return PaintImage(stable_image_id_, ImageForCurrentFrame(), animation_type,
+                    completion_state);
 }
 
 bool Image::ApplyShader(PaintFlags& flags, const SkMatrix& local_matrix) {
   // Default shader impl: attempt to build a shader based on the current frame
   // SkImage.
   sk_sp<SkImage> image = ImageForCurrentFrame();
   if (!image)
     return false;
 
   flags.setShader(image->makeShader(SkShader::kRepeat_TileMode,
@@ skipping 35 matching lines @@
   FloatRect subset = dest;
   subset.SetX((dest.X() - tile.X()) / scale.Width());
   subset.SetY((dest.Y() - tile.Y()) / scale.Height());
   subset.SetWidth(dest.Width() / scale.Width());
   subset.SetHeight(dest.Height() / scale.Height());
 
   return subset;
 }
 
 }  // namespace blink