scoped_raster_flags_unittest.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "cc/paint/scoped_raster_flags.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/callback.h"
  8. #include "cc/paint/paint_op_buffer.h"
  9. #include "cc/paint/paint_shader.h"
  10. #include "cc/test/skia_common.h"
  11. #include "cc/test/test_paint_worklet_input.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. #include "third_party/skia/include/core/SkBitmap.h"
  14. #include "third_party/skia/include/core/SkImage.h"
  15. #include "third_party/skia/include/core/SkMatrix.h"
  16. #include "third_party/skia/include/core/SkPaint.h"
  17. #include "third_party/skia/include/core/SkRect.h"
  18. #include "third_party/skia/include/core/SkRefCnt.h"
  19. #include "third_party/skia/include/core/SkSize.h"
  20. #include "third_party/skia/include/core/SkTileMode.h"
  21. namespace cc {
  22. namespace {
  23. class MockImageProvider : public ImageProvider {
  24. public:
  25. MockImageProvider() = default;
  26. ~MockImageProvider() override { EXPECT_EQ(ref_count_, 0); }
  27. ScopedResult GetRasterContent(const DrawImage& draw_image) override {
  28. DCHECK(!draw_image.paint_image().IsPaintWorklet());
  29. ref_count_++;
  30. SkBitmap bitmap;
  31. bitmap.allocN32Pixels(10, 10);
  32. sk_sp<SkImage> image = SkImage::MakeFromBitmap(bitmap);
  33. return ScopedResult(
  34. DecodedDrawImage(image, nullptr, SkSize::MakeEmpty(),
  35. SkSize::Make(1.0f, 1.0f), draw_image.filter_quality(),
  36. true),
  37. base::BindOnce(&MockImageProvider::UnrefImage, base::Unretained(this)));
  38. }
  39. void UnrefImage() {
  40. ref_count_--;
  41. CHECK_GE(ref_count_, 0);
  42. }
  43. int ref_count() const { return ref_count_; }
  44. private:
  45. int ref_count_ = 0;
  46. };
  47. class MockPaintWorkletImageProvider : public ImageProvider {
  48. public:
  49. MockPaintWorkletImageProvider() = default;
  50. ~MockPaintWorkletImageProvider() override = default;
  51. ScopedResult GetRasterContent(const DrawImage& draw_image) override {
  52. auto record = sk_make_sp<PaintOpBuffer>();
  53. return ScopedResult(std::move(record));
  54. }
  55. };
  56. } // namespace
  57. TEST(ScopedRasterFlagsTest, DecodePaintWorkletImageShader) {
  58. float width = 100;
  59. float height = 100;
  60. scoped_refptr<TestPaintWorkletInput> input =
  61. base::MakeRefCounted<TestPaintWorkletInput>(gfx::SizeF(width, height));
  62. auto image = CreatePaintWorkletPaintImage(input);
  63. SkMatrix pattern_matrix;
  64. SkRect tile_rect = SkRect::MakeXYWH(0, 0, width, height);
  65. auto shader =
  66. PaintShader::MakeImage(image, SkTileMode::kRepeat, SkTileMode::kRepeat,
  67. &pattern_matrix, &tile_rect);
  68. PaintFlags flags;
  69. flags.setShader(shader);
  70. MockPaintWorkletImageProvider provider;
  71. ScopedRasterFlags scoped_flags(&flags, &provider, SkMatrix::I(), 0, 1.0f);
  72. ASSERT_TRUE(scoped_flags.flags());
  73. EXPECT_TRUE(scoped_flags.flags()->getShader()->shader_type() ==
  74. PaintShader::Type::kPaintRecord);
  75. }
  76. TEST(ScopedRasterFlagsTest, KeepsDecodesAlive) {
  77. auto record = sk_make_sp<PaintOpBuffer>();
  78. record->push<DrawImageOp>(CreateDiscardablePaintImage(gfx::Size(10, 10)), 0.f,
  79. 0.f);
  80. record->push<DrawImageOp>(CreateDiscardablePaintImage(gfx::Size(10, 10)), 0.f,
  81. 0.f);
  82. record->push<DrawImageOp>(CreateDiscardablePaintImage(gfx::Size(10, 10)), 0.f,
  83. 0.f);
  84. auto record_shader = PaintShader::MakePaintRecord(
  85. record, SkRect::MakeWH(100, 100), SkTileMode::kClamp, SkTileMode::kClamp,
  86. &SkMatrix::I());
  87. record_shader->set_has_animated_images(true);
  88. MockImageProvider provider;
  89. PaintFlags flags;
  90. flags.setShader(record_shader);
  91. {
  92. ScopedRasterFlags scoped_flags(&flags, &provider, SkMatrix::I(), 0, 1.0f);
  93. ASSERT_TRUE(scoped_flags.flags());
  94. EXPECT_NE(scoped_flags.flags(), &flags);
  95. SkPaint paint = scoped_flags.flags()->ToSkPaint();
  96. ASSERT_TRUE(paint.getShader());
  97. EXPECT_EQ(provider.ref_count(), 3);
  98. }
  99. EXPECT_EQ(provider.ref_count(), 0);
  100. }
  101. TEST(ScopedRasterFlagsTest, NoImageProvider) {
  102. PaintFlags flags;
  103. flags.setAlphaf(1.0f);
  104. flags.setShader(PaintShader::MakeImage(
  105. CreateDiscardablePaintImage(gfx::Size(10, 10)), SkTileMode::kClamp,
  106. SkTileMode::kClamp, &SkMatrix::I()));
  107. ScopedRasterFlags scoped_flags(&flags, nullptr, SkMatrix::I(), 0, 0.1f);
  108. EXPECT_NE(scoped_flags.flags(), &flags);
  109. EXPECT_EQ(scoped_flags.flags()->getAlphaf(), 1.0f * 0.1f);
  110. }
  111. TEST(ScopedRasterFlagsTest, ThinAliasedStroke) {
  112. PaintFlags flags;
  113. flags.setStyle(PaintFlags::kStroke_Style);
  114. flags.setStrokeWidth(1);
  115. flags.setAntiAlias(false);
  116. struct {
  117. SkMatrix ctm;
  118. float alpha;
  119. bool expect_same_flags;
  120. bool expect_aa;
  121. float expect_stroke_width;
  122. float expect_alpha;
  123. } tests[] = {
  124. // No downscaling => no stroke change.
  125. {SkMatrix::Scale(1.0f, 1.0f), 1.0f, true, false, 1.0f, 1.0f},
  126. // Symmetric downscaling => modulated hairline stroke.
  127. {SkMatrix::Scale(0.5f, 0.5f), 1.0f, false, false, 0.0f, 0.5f},
  128. // Symmetric downscaling w/ alpha => modulated hairline stroke.
  129. {SkMatrix::Scale(0.5f, 0.5f), 0.5f, false, false, 0.0f, 0.25f},
  130. // Anisotropic scaling => AA stroke.
  131. {SkMatrix::Scale(0.5f, 1.5f), 1.0f, false, true, 1.0f, 1.0f},
  132. };
  133. for (const auto& test : tests) {
  134. ScopedRasterFlags scoped_flags(&flags, nullptr, test.ctm, 0, test.alpha);
  135. ASSERT_TRUE(scoped_flags.flags());
  136. EXPECT_EQ(scoped_flags.flags() == &flags, test.expect_same_flags);
  137. EXPECT_EQ(scoped_flags.flags()->isAntiAlias(), test.expect_aa);
  138. EXPECT_EQ(scoped_flags.flags()->getStrokeWidth(), test.expect_stroke_width);
  139. EXPECT_LE(std::abs(scoped_flags.flags()->getAlphaf() - test.expect_alpha),
  140. 0.01f);
  141. }
  142. }
  143. } // namespace cc