cc: Ensure bitmap backed images are tracked as discardable.

Since GPU raster uses the GpuImageDecodeCache for image uploads,
ensuring that the image is tracked as discardable avoids at-raster
caching for them which has more ref/unref overhead.

R=ericrk@chromium.org

Bug: 894200
Change-Id: I9d40ab5e0d7c2c2e4a12d7ab8be318cfcba2f590
Reviewed-on: https://chromium-review.googlesource.com/c/1292813Reviewed-by: Eric Karl <ericrk@chromium.org>
Commit-Queue: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#601717}

cc/layers/recording_source_unittest.cc

@@ -160,12 +160,8 @@ TEST(RecordingSourceTest, NoDiscardableImages) {
   PaintFlags simple_flags;
   simple_flags.setColor(SkColorSetARGB(255, 12, 23, 34));
 
-  SkBitmap non_discardable_bitmap;
-  non_discardable_bitmap.allocN32Pixels(128, 128);
-  non_discardable_bitmap.setImmutable();
-  sk_sp<SkImage> non_discardable_image =
-      SkImage::MakeFromBitmap(non_discardable_bitmap);
-
+  auto non_discardable_image =
+      CreateNonDiscardablePaintImage(gfx::Size(128, 128));
   recording_source->add_draw_rect_with_flags(gfx::Rect(0, 0, 256, 256),
                                              simple_flags);
   recording_source->add_draw_rect_with_flags(gfx::Rect(128, 128, 512, 512),
@@ -274,12 +270,8 @@ TEST(RecordingSourceTest, DiscardableImagesBaseNonDiscardable) {
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
-
-  SkBitmap non_discardable_bitmap;
-  non_discardable_bitmap.allocN32Pixels(512, 512);
-  non_discardable_bitmap.setImmutable();
-  sk_sp<SkImage> non_discardable_image =
-      SkImage::MakeFromBitmap(non_discardable_bitmap);
+  PaintImage non_discardable_image =
+      CreateNonDiscardablePaintImage(gfx::Size(512, 512));
 
   PaintImage discardable_image[2][2];
   discardable_image[0][0] = CreateDiscardablePaintImage(gfx::Size(128, 128));

cc/paint/discardable_image_map.cc

@@ -349,7 +349,7 @@ class DiscardableImageGenerator {
                 const gfx::Rect& image_rect,
                 const SkMatrix& matrix,
                 SkFilterQuality filter_quality) {
-    if (!paint_image.IsLazyGenerated())
+    if (paint_image.IsTextureBacked())
       return;
 
     SkIRect src_irect;

cc/paint/oop_pixeltest.cc

@@ -139,6 +139,7 @@ class OopPixelTest : public testing::Test,
     SkColor preclear_color;
     ImageDecodeCache* image_cache = nullptr;
     std::vector<scoped_refptr<DisplayItemList>> additional_lists;
+    PaintShader* shader_with_animated_images = nullptr;
   };
 
   SkBitmap Raster(scoped_refptr<DisplayItemList> display_item_list,
@@ -274,6 +275,9 @@ class OopPixelTest : public testing::Test,
                                           layer_rect);
     recording.SetRequiresClear(options.requires_clear);
 
+    if (options.shader_with_animated_images)
+      options.shader_with_animated_images->set_has_animated_images(true);
+
     PlaybackImageProvider image_provider(gpu_image_cache_.get(),
                                          options.color_space,
                                          PlaybackImageProvider::Settings());
@@ -604,9 +608,6 @@ TEST_P(OopImagePixelTest, DrawRecordShaderWithImageScaled) {
   auto paint_record_shader = PaintShader::MakePaintRecord(
       paint_record, gfx::RectToSkRect(rect), SkShader::kRepeat_TileMode,
       SkShader::kRepeat_TileMode, nullptr);
-  // Set the shader has animated images so gpu also goes through cc's image
-  // upload stack, instead of using skia.
-  paint_record_shader->set_has_animated_images(true);
 
   auto display_item_list = base::MakeRefCounted<DisplayItemList>();
   display_item_list->StartPaint();
@@ -619,7 +620,11 @@ TEST_P(OopImagePixelTest, DrawRecordShaderWithImageScaled) {
   display_item_list->Finalize();
 
   auto actual = Raster(display_item_list, rect.size());
-  auto expected = RasterExpectedBitmap(display_item_list, rect.size());
+  // Set the shader has animated images so gpu also goes through cc's image
+  // upload stack, instead of using skia.
+  RasterOptions expected_options(rect.size());
+  expected_options.shader_with_animated_images = paint_record_shader.get();
+  auto expected = RasterExpectedBitmap(display_item_list, expected_options);
   ExpectEquals(actual, expected);
 }
 

cc/paint/paint_filter.cc

@@ -668,7 +668,7 @@ ImagePaintFilter::ImagePaintFilter(PaintImage image,
                                    const SkRect& src_rect,
                                    const SkRect& dst_rect,
                                    SkFilterQuality filter_quality)
-    : PaintFilter(kType, nullptr, image.IsLazyGenerated()),
+    : PaintFilter(kType, nullptr, !image.IsTextureBacked()),
       image_(std::move(image)),
       src_rect_(src_rect),
       dst_rect_(dst_rect),

cc/paint/paint_filter_unittest.cc

@@ -33,7 +33,7 @@ sk_sp<PaintFilter> CreateTestFilter(PaintFilter::Type filter_type,
   if (has_discardable_images)
     image = CreateDiscardablePaintImage(gfx::Size(100, 100));
   else
-    image = CreateBitmapImage(gfx::Size(100, 100));
+    image = CreateNonDiscardablePaintImage(gfx::Size(100, 100));
 
   auto image_filter = sk_make_sp<ImagePaintFilter>(
       image, SkRect::MakeWH(100.f, 100.f), SkRect::MakeWH(100.f, 100.f),

cc/paint/paint_image.h

@@ -162,6 +162,7 @@ class CC_PAINT_EXPORT PaintImage {
   uint32_t unique_id() const { return GetSkImage()->uniqueID(); }
   explicit operator bool() const { return !!GetSkImage(); }
   bool IsLazyGenerated() const { return GetSkImage()->isLazyGenerated(); }
+  bool IsTextureBacked() const { return GetSkImage()->isTextureBacked(); }
   int width() const { return GetSkImage()->width(); }
   int height() const { return GetSkImage()->height(); }
   SkColorSpace* color_space() const { return GetSkImage()->colorSpace(); }

cc/paint/paint_op_buffer.cc

@@ -2132,9 +2132,7 @@ DrawImageOp::DrawImageOp(const PaintImage& image,
       top(top) {}
 
 bool DrawImageOp::HasDiscardableImages() const {
-  // TODO(khushalsagar): Callers should not be able to change the lazy generated
-  // state for a PaintImage.
-  return image && image.IsLazyGenerated();
+  return image && !image.IsTextureBacked();
 }
 
 DrawImageOp::~DrawImageOp() = default;
@@ -2153,7 +2151,7 @@ DrawImageRectOp::DrawImageRectOp(const PaintImage& image,
       constraint(constraint) {}
 
 bool DrawImageRectOp::HasDiscardableImages() const {
-  return image && image.IsLazyGenerated();
+  return image && !image.IsTextureBacked();
 }
 
 DrawImageRectOp::~DrawImageRectOp() = default;

cc/paint/paint_shader.cc

@@ -214,7 +214,7 @@ PaintShader::PaintShader(Type type) : shader_type_(type) {}
 PaintShader::~PaintShader() = default;
 
 bool PaintShader::has_discardable_images() const {
-  return (image_ && image_.IsLazyGenerated()) ||
+  return (image_ && !image_.IsTextureBacked()) ||
          (record_ && record_->HasDiscardableImages());
 }
 

cc/test/skia_common.cc

@@ -16,6 +16,8 @@
 #include "cc/test/fake_paint_image_generator.h"
 #include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/core/SkPixmap.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
@@ -179,4 +181,20 @@ scoped_refptr<SkottieWrapper> CreateSkottie(const gfx::Size& size,
       std::make_unique<SkMemoryStream>(json.c_str(), json.size()));
 }
 
+PaintImage CreateNonDiscardablePaintImage(const gfx::Size& size) {
+  sk_sp<const GrGLInterface> gl_interface(GrGLCreateNullInterface());
+  auto context = GrContext::MakeGL(std::move(gl_interface));
+  SkBitmap bitmap;
+  auto info = SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType,
+                                kPremul_SkAlphaType, nullptr /* color_space */);
+  bitmap.allocPixels(info);
+  bitmap.eraseColor(SK_AlphaTRANSPARENT);
+  return PaintImageBuilder::WithDefault()
+      .set_id(PaintImage::GetNextId())
+      .set_image(SkImage::MakeFromBitmap(bitmap)->makeTextureImage(
+                     context.get(), nullptr),
+                 PaintImage::GetNextContentId())
+      .TakePaintImage();
+}
+
 }  // namespace cc

cc/test/skia_common.h

@@ -64,6 +64,8 @@ PaintImage CreateBitmapImage(const gfx::Size& size,
 scoped_refptr<SkottieWrapper> CreateSkottie(const gfx::Size& size,
                                             int duration_secs);
 
+PaintImage CreateNonDiscardablePaintImage(const gfx::Size& size);
+
 }  // namespace cc
 
 #endif  // CC_TEST_SKIA_COMMON_H_