Update GatherPixelRefDevice to the new SkImage/SkPixelRef API

skia/ext/pixel_ref_utils_unittest.cc

 // Copyright 2014 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 "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/test/geometry_test_utils.h"
 #include "skia/ext/pixel_ref_utils.h"
 #include "skia/ext/refptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImage.h"
+#include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/src/core/SkOrderedReadBuffer.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace skia {
 
 namespace {
 
-void CreateBitmap(gfx::Size size, const char* uri, SkBitmap* bitmap);
+class TestImageGenerator : public SkImageGenerator {
+  public:
+   TestImageGenerator(const SkImageInfo& info)
+     : SkImageGenerator(info) { }
+};
+
+void CreateDiscardableBitmap(const gfx::Size& size, SkBitmap* bitmap) {
+  const SkImageInfo info =
+      SkImageInfo::MakeN32Premul(size.width(), size.height());
+  SkInstallDiscardablePixelRef(new TestImageGenerator(info), bitmap);
+}
+
+skia::RefPtr<SkImage> CreateDiscardableImage(const gfx::Size& size) {
+  const SkImageInfo info =
+      SkImageInfo::MakeN32Premul(size.width(), size.height());
+  return skia::AdoptRef(
+      SkImage::NewFromGenerator(new TestImageGenerator(info)));
+}
 
 class TestDiscardableShader : public SkShader {
  public:
   TestDiscardableShader() {
-    CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
+    CreateDiscardableBitmap(gfx::Size(50, 50), &bitmap_);
   }
 
   TestDiscardableShader(SkReadBuffer& buffer) {
-    CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
+    CreateDiscardableBitmap(gfx::Size(50, 50), &bitmap_);
   }
 
   SkShader::BitmapType asABitmap(SkBitmap* bitmap,
                                  SkMatrix* matrix,
                                  TileMode xy[2]) const override {
     if (bitmap)
       *bitmap = bitmap_;
     return SkShader::kDefault_BitmapType;
   }
 
@@ skipping 12 matching lines @@
   Factory getFactory() const override { return CreateProc; }
 
  private:
   SkBitmap bitmap_;
 };
 
 SkFlattenable* TestDiscardableShader::CreateProc(SkReadBuffer&) {
   return new TestDiscardableShader;
 }
 
-void CreateBitmap(gfx::Size size, const char* uri, SkBitmap* bitmap) {
-  bitmap->allocN32Pixels(size.width(), size.height());
-  bitmap->pixelRef()->setImmutable();
-  bitmap->pixelRef()->setURI(uri);
-}
-
 SkCanvas* StartRecording(SkPictureRecorder* recorder, gfx::Rect layer_rect) {
   SkCanvas* canvas =
       recorder->beginRecording(layer_rect.width(), layer_rect.height());
 
   canvas->save();
   canvas->translate(-layer_rect.x(), -layer_rect.y());
   canvas->clipRect(SkRect::MakeXYWH(
       layer_rect.x(), layer_rect.y(), layer_rect.width(), layer_rect.height()));
 
   return canvas;
@@ skipping 354 matching lines @@
   EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[1].filter_quality);
 }
 
 TEST(PixelRefUtilsTest, DrawBitmap) {
   gfx::Rect layer_rect(0, 0, 256, 256);
 
   SkPictureRecorder recorder;
   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 
   SkBitmap first;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &first);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &first);
   SkBitmap second;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &second);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &second);
   SkBitmap third;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &third);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &third);
   SkBitmap fourth;
-  CreateBitmap(gfx::Size(50, 1), "discardable", &fourth);
+  CreateDiscardableBitmap(gfx::Size(50, 1), &fourth);
   SkBitmap fifth;
-  CreateBitmap(gfx::Size(10, 10), "discardable", &fifth);
+  CreateDiscardableBitmap(gfx::Size(10, 10), &fifth);
   SkBitmap sixth;
-  CreateBitmap(gfx::Size(10, 10), "discardable", &sixth);
+  CreateDiscardableBitmap(gfx::Size(10, 10), &sixth);
 
   canvas->save();
 
   // At (0, 0).
   canvas->drawBitmap(first, 0, 0);
   canvas->translate(25, 0);
   // At (25, 0).
   canvas->drawBitmap(second, 0, 0);
   canvas->translate(0, 50);
   // At (50, 50).
@@ skipping 56 matching lines @@
   EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[5].filter_quality);
 }
 
 TEST(PixelRefUtilsTest, DrawBitmapRect) {
   gfx::Rect layer_rect(0, 0, 256, 256);
 
   SkPictureRecorder recorder;
   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 
   SkBitmap first;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &first);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &first);
   SkBitmap second;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &second);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &second);
   SkBitmap third;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &third);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &third);
 
   TestDiscardableShader first_shader;
   SkPaint first_paint;
   first_paint.setShader(&first_shader);
 
   SkPaint non_discardable_paint;
 
   canvas->save();
 
   // (0, 0, 100, 100).
@@ skipping 35 matching lines @@
   EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[3].filter_quality);
 }
 
 TEST(PixelRefUtilsTest, DrawSprite) {
   gfx::Rect layer_rect(0, 0, 256, 256);
 
   SkPictureRecorder recorder;
   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 
   SkBitmap first;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &first);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &first);
   SkBitmap second;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &second);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &second);
   SkBitmap third;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &third);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &third);
   SkBitmap fourth;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &fourth);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &fourth);
   SkBitmap fifth;
-  CreateBitmap(gfx::Size(50, 50), "discardable", &fifth);
+  CreateDiscardableBitmap(gfx::Size(50, 50), &fifth);
 
   canvas->save();
 
   // Sprites aren't affected by the current matrix.
 
   // (0, 0, 50, 50).
   canvas->drawSprite(first, 0, 0);
   canvas->translate(25, 0);
   // (10, 0, 50, 50).
   canvas->drawSprite(second, 10, 0);
@@ skipping 167 matching lines @@
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 10, 90, 90),
                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
   VerifyScales(1.f, 1.f, pixel_refs[1].matrix, __LINE__);
   EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[1].filter_quality);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 55, 150, 145),
                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
   VerifyScales(1.f, 1.f, pixel_refs[2].matrix, __LINE__);
   EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[2].filter_quality);
 }
 
+TEST(PixelRefUtilsTest, DrawImage) {
+  gfx::Rect layer_rect(0, 0, 256, 256);
+
+  SkPictureRecorder recorder;
+  SkCanvas* canvas = StartRecording(&recorder, layer_rect);
+
+  skia::RefPtr<SkImage> first = CreateDiscardableImage(gfx::Size(50, 50));
+  skia::RefPtr<SkImage> second = CreateDiscardableImage(gfx::Size(50, 50));
+  skia::RefPtr<SkImage> third = CreateDiscardableImage(gfx::Size(50, 50));
+  skia::RefPtr<SkImage> fourth = CreateDiscardableImage(gfx::Size(50, 1));
+  skia::RefPtr<SkImage> fifth = CreateDiscardableImage(gfx::Size(10, 10));
+  skia::RefPtr<SkImage> sixth = CreateDiscardableImage(gfx::Size(10, 10));
+
+  canvas->save();
+
+  // At (0, 0).
+  canvas->drawImage(first.get(), 0, 0);
+  canvas->translate(25, 0);
+  // At (25, 0).
+  canvas->drawImage(second.get(), 0, 0);
+  canvas->translate(0, 50);
+  // At (50, 50).
+  canvas->drawImage(third.get(), 25, 0);
+
+  canvas->restore();
+  canvas->save();
+
+  canvas->translate(1, 0);
+  canvas->rotate(90);
+  // At (1, 0), rotated 90 degrees
+  canvas->drawImage(fourth.get(), 0, 0);
+
+  canvas->restore();
+  canvas->save();
+
+  canvas->scale(5.f, 6.f);
+  // At (0, 0), scaled by 5 and 6
+  canvas->drawImage(fifth.get(), 0, 0);
+
+  canvas->restore();
+
+  canvas->rotate(27);
+  canvas->scale(3.3f, 0.4f);
+
+  canvas->drawImage(sixth.get(), 0, 0);
+
+  canvas->restore();
+
+  skia::RefPtr<SkPicture> picture =
+      skia::AdoptRef(StopRecording(&recorder, canvas));
+
+  std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
+  skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
+
+  EXPECT_EQ(6u, pixel_refs.size());
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 50),
+                       gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
+  VerifyScales(1.f, 1.f, pixel_refs[0].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[0].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(25, 0, 50, 50),
+                       gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
+  VerifyScales(1.f, 1.f, pixel_refs[1].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[1].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 50, 50, 50),
+                       gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
+  VerifyScales(1.f, 1.f, pixel_refs[2].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[2].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 1, 50),
+                       gfx::SkRectToRectF(pixel_refs[3].pixel_ref_rect));
+  VerifyScales(1.f, 1.f, pixel_refs[3].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[3].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 60),
+                       gfx::SkRectToRectF(pixel_refs[4].pixel_ref_rect));
+  VerifyScales(5.f, 6.f, pixel_refs[4].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[4].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(-1.8159621f, 0, 31.219175f, 18.545712f),
+                       gfx::SkRectToRectF(pixel_refs[5].pixel_ref_rect));
+  VerifyScales(3.3f, 0.4f, pixel_refs[5].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[5].filter_quality);
+}
+
+TEST(PixelRefUtilsTest, DrawImageRect) {
+  gfx::Rect layer_rect(0, 0, 256, 256);
+
+  SkPictureRecorder recorder;
+  SkCanvas* canvas = StartRecording(&recorder, layer_rect);
+
+  skia::RefPtr<SkImage> first = CreateDiscardableImage(gfx::Size(50, 50));
+  skia::RefPtr<SkImage> second = CreateDiscardableImage(gfx::Size(50, 50));
+  skia::RefPtr<SkImage> third = CreateDiscardableImage(gfx::Size(50, 50));
+
+  TestDiscardableShader first_shader;
+  SkPaint first_paint;
+  first_paint.setShader(&first_shader);
+
+  SkPaint non_discardable_paint;
+
+  canvas->save();
+
+  // (0, 0, 100, 100).
+  canvas->drawImageRect(
+      first.get(), SkRect::MakeWH(100, 100), &non_discardable_paint);
+  canvas->translate(25, 0);
+  // (75, 50, 10, 10).
+  canvas->drawImageRect(
+      second.get(), SkRect::MakeXYWH(50, 50, 10, 10), &non_discardable_paint);
+  canvas->translate(5, 50);
+  // (0, 30, 100, 100). One from bitmap, one from paint.
+  canvas->drawImageRect(
+      third.get(), SkRect::MakeXYWH(-30, -20, 100, 100), &first_paint);
+
+  canvas->restore();
+
+  skia::RefPtr<SkPicture> picture =
+      skia::AdoptRef(StopRecording(&recorder, canvas));
+
+  std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
+  skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
+
+  EXPECT_EQ(4u, pixel_refs.size());
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100),
+                       gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
+  VerifyScales(2.f, 2.f, pixel_refs[0].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[0].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(75, 50, 10, 10),
+                       gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
+  VerifyScales(0.2f, 0.2f, pixel_refs[1].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[1].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 30, 100, 100),
+                       gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
+  VerifyScales(2.f, 2.f, pixel_refs[2].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[2].filter_quality);
+  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 30, 100, 100),
+                       gfx::SkRectToRectF(pixel_refs[3].pixel_ref_rect));
+  VerifyScales(2.f, 2.f, pixel_refs[3].matrix, __LINE__);
+  EXPECT_EQ(kNone_SkFilterQuality, pixel_refs[3].filter_quality);
+}
+
 }  // namespace skia