discardable_image_map_unittest.cc 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329
  1. // Copyright 2015 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/discardable_image_map.h"
  5. #include <stddef.h>
  6. #include <algorithm>
  7. #include <limits>
  8. #include <memory>
  9. #include "base/memory/ref_counted.h"
  10. #include "base/test/gtest_util.h"
  11. #include "base/values.h"
  12. #include "cc/base/region.h"
  13. #include "cc/paint/paint_flags.h"
  14. #include "cc/paint/paint_op_buffer.h"
  15. #include "cc/paint/paint_recorder.h"
  16. #include "cc/paint/skottie_color_map.h"
  17. #include "cc/paint/skottie_frame_data.h"
  18. #include "cc/paint/skottie_resource_metadata.h"
  19. #include "cc/test/fake_content_layer_client.h"
  20. #include "cc/test/fake_recording_source.h"
  21. #include "cc/test/lottie_test_data.h"
  22. #include "cc/test/skia_common.h"
  23. #include "cc/test/test_paint_worklet_input.h"
  24. #include "skia/buildflags.h"
  25. #include "testing/gmock/include/gmock/gmock.h"
  26. #include "testing/gtest/include/gtest/gtest.h"
  27. #include "third_party/skia/include/core/SkCanvas.h"
  28. #include "third_party/skia/include/core/SkGraphics.h"
  29. #include "third_party/skia/include/core/SkImageGenerator.h"
  30. #include "third_party/skia/include/core/SkRefCnt.h"
  31. #include "ui/gfx/color_space.h"
  32. #include "ui/gfx/geometry/rect.h"
  33. #include "ui/gfx/geometry/skia_conversions.h"
  34. namespace cc {
  35. namespace {
  36. using ::testing::Contains;
  37. using ::testing::Eq;
  38. using ::testing::Field;
  39. using ::testing::FloatNear;
  40. using ::testing::IsEmpty;
  41. using ::testing::SizeIs;
  42. using Rects = base::StackVector<gfx::Rect, 1>;
  43. struct PositionScaleDrawImage {
  44. PositionScaleDrawImage(const PaintImage& image,
  45. const gfx::Rect& image_rect,
  46. const SkSize& scale)
  47. : image(image), image_rect(image_rect), scale(scale) {}
  48. PaintImage image;
  49. gfx::Rect image_rect;
  50. SkSize scale;
  51. };
  52. sk_sp<PaintOpBuffer> CreateRecording(const PaintImage& discardable_image,
  53. const gfx::Rect& visible_rect) {
  54. auto buffer = sk_make_sp<PaintOpBuffer>();
  55. buffer->push<DrawImageOp>(discardable_image, 0.f, 0.f);
  56. return buffer;
  57. }
  58. } // namespace
  59. class DiscardableImageMapTest : public testing::Test {
  60. public:
  61. std::vector<PositionScaleDrawImage> GetDiscardableImagesInRect(
  62. const DiscardableImageMap& image_map,
  63. const gfx::Rect& rect) {
  64. std::vector<const DrawImage*> draw_image_ptrs;
  65. // Choose a not-SRGB-and-not-invalid target color space to verify that it
  66. // is passed correctly to the resulting DrawImages.
  67. const TargetColorParams target_color_params(
  68. gfx::ColorSpace::CreateXYZD50());
  69. image_map.GetDiscardableImagesInRect(rect, &draw_image_ptrs);
  70. std::vector<DrawImage> draw_images;
  71. for (const auto* image : draw_image_ptrs)
  72. draw_images.push_back(DrawImage(
  73. *image, 1.f, PaintImage::kDefaultFrameIndex, target_color_params));
  74. std::vector<PositionScaleDrawImage> position_draw_images;
  75. std::vector<DrawImage> results;
  76. image_map.images_rtree_.Search(rect, &results);
  77. for (DrawImage& image : results) {
  78. auto image_id = image.paint_image().stable_id();
  79. position_draw_images.push_back(PositionScaleDrawImage(
  80. image.paint_image(),
  81. ImageRectsToRegion(image_map.GetRectsForImage(image_id)).bounds(),
  82. image.scale()));
  83. }
  84. EXPECT_EQ(draw_images.size(), position_draw_images.size());
  85. for (size_t i = 0; i < draw_images.size(); ++i) {
  86. EXPECT_TRUE(draw_images[i].paint_image() ==
  87. position_draw_images[i].image);
  88. EXPECT_EQ(draw_images[i].target_color_space(),
  89. target_color_params.color_space);
  90. }
  91. return position_draw_images;
  92. }
  93. // Note that the image rtree outsets the images by 1, see the comment in
  94. // DiscardableImagesMetadataCanvas::AddImage.
  95. std::vector<gfx::Rect> InsetImageRects(
  96. const std::vector<PositionScaleDrawImage>& images) {
  97. std::vector<gfx::Rect> result;
  98. for (auto& image : images) {
  99. result.push_back(image.image_rect);
  100. result.back().Inset(1);
  101. }
  102. return result;
  103. }
  104. };
  105. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectTest) {
  106. gfx::Rect visible_rect(2048, 2048);
  107. FakeContentLayerClient content_layer_client;
  108. content_layer_client.set_bounds(visible_rect.size());
  109. // Discardable pixel refs are found in the following grids:
  110. // |---|---|---|---|
  111. // | | x | | x |
  112. // |---|---|---|---|
  113. // | x | | x | |
  114. // |---|---|---|---|
  115. // | | x | | x |
  116. // |---|---|---|---|
  117. // | x | | x | |
  118. // |---|---|---|---|
  119. PaintImage discardable_image[4][4];
  120. for (int y = 0; y < 4; ++y) {
  121. for (int x = 0; x < 4; ++x) {
  122. if ((x + y) & 1) {
  123. discardable_image[y][x] =
  124. CreateDiscardablePaintImage(gfx::Size(500, 500));
  125. content_layer_client.add_draw_image(
  126. discardable_image[y][x], gfx::Point(x * 512 + 6, y * 512 + 6));
  127. }
  128. }
  129. }
  130. scoped_refptr<DisplayItemList> display_list =
  131. content_layer_client.PaintContentsToDisplayList();
  132. display_list->GenerateDiscardableImagesMetadata();
  133. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  134. for (int y = 0; y < 4; ++y) {
  135. for (int x = 0; x < 4; ++x) {
  136. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  137. image_map, gfx::Rect(x * 512, y * 512, 500, 500));
  138. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  139. if ((x + y) & 1) {
  140. EXPECT_EQ(1u, images.size()) << x << " " << y;
  141. EXPECT_TRUE(images[0].image == discardable_image[y][x])
  142. << x << " " << y;
  143. EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
  144. inset_rects[0]);
  145. } else {
  146. EXPECT_EQ(0u, images.size()) << x << " " << y;
  147. }
  148. }
  149. }
  150. // Capture 4 pixel refs.
  151. std::vector<PositionScaleDrawImage> images =
  152. GetDiscardableImagesInRect(image_map, gfx::Rect(512, 512, 2048, 2048));
  153. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  154. EXPECT_EQ(4u, images.size());
  155. EXPECT_TRUE(images[0].image == discardable_image[1][2]);
  156. EXPECT_EQ(gfx::Rect(2 * 512 + 6, 512 + 6, 500, 500), inset_rects[0]);
  157. EXPECT_TRUE(images[1].image == discardable_image[2][1]);
  158. EXPECT_EQ(gfx::Rect(512 + 6, 2 * 512 + 6, 500, 500), inset_rects[1]);
  159. EXPECT_TRUE(images[2].image == discardable_image[2][3]);
  160. EXPECT_EQ(gfx::Rect(3 * 512 + 6, 2 * 512 + 6, 500, 500), inset_rects[2]);
  161. EXPECT_TRUE(images[3].image == discardable_image[3][2]);
  162. EXPECT_EQ(gfx::Rect(2 * 512 + 6, 3 * 512 + 6, 500, 500), inset_rects[3]);
  163. }
  164. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectNonZeroLayer) {
  165. gfx::Rect visible_rect(1024, 0, 2048, 2048);
  166. // Make sure visible rect fits into the layer size.
  167. gfx::Size layer_size(visible_rect.right(), visible_rect.bottom());
  168. FakeContentLayerClient content_layer_client;
  169. content_layer_client.set_bounds(layer_size);
  170. // Discardable pixel refs are found in the following grids:
  171. // |---|---|---|---|
  172. // | | x | | x |
  173. // |---|---|---|---|
  174. // | x | | x | |
  175. // |---|---|---|---|
  176. // | | x | | x |
  177. // |---|---|---|---|
  178. // | x | | x | |
  179. // |---|---|---|---|
  180. PaintImage discardable_image[4][4];
  181. for (int y = 0; y < 4; ++y) {
  182. for (int x = 0; x < 4; ++x) {
  183. if ((x + y) & 1) {
  184. discardable_image[y][x] =
  185. CreateDiscardablePaintImage(gfx::Size(500, 500));
  186. content_layer_client.add_draw_image(
  187. discardable_image[y][x],
  188. gfx::Point(1024 + x * 512 + 6, y * 512 + 6));
  189. }
  190. }
  191. }
  192. scoped_refptr<DisplayItemList> display_list =
  193. content_layer_client.PaintContentsToDisplayList();
  194. display_list->GenerateDiscardableImagesMetadata();
  195. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  196. for (int y = 0; y < 4; ++y) {
  197. for (int x = 0; x < 4; ++x) {
  198. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  199. image_map, gfx::Rect(1024 + x * 512, y * 512, 500, 500));
  200. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  201. if ((x + y) & 1) {
  202. EXPECT_EQ(1u, images.size()) << x << " " << y;
  203. EXPECT_TRUE(images[0].image == discardable_image[y][x])
  204. << x << " " << y;
  205. EXPECT_EQ(gfx::Rect(1024 + x * 512 + 6, y * 512 + 6, 500, 500),
  206. inset_rects[0]);
  207. } else {
  208. EXPECT_EQ(0u, images.size()) << x << " " << y;
  209. }
  210. }
  211. }
  212. // Capture 4 pixel refs.
  213. {
  214. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  215. image_map, gfx::Rect(1024 + 512, 512, 2048, 2048));
  216. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  217. EXPECT_EQ(4u, images.size());
  218. EXPECT_TRUE(images[0].image == discardable_image[1][2]);
  219. EXPECT_EQ(gfx::Rect(1024 + 2 * 512 + 6, 512 + 6, 500, 500), inset_rects[0]);
  220. EXPECT_TRUE(images[1].image == discardable_image[2][1]);
  221. EXPECT_EQ(gfx::Rect(1024 + 512 + 6, 2 * 512 + 6, 500, 500), inset_rects[1]);
  222. EXPECT_TRUE(images[2].image == discardable_image[2][3]);
  223. EXPECT_EQ(gfx::Rect(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500),
  224. inset_rects[2]);
  225. EXPECT_TRUE(images[3].image == discardable_image[3][2]);
  226. EXPECT_EQ(gfx::Rect(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500),
  227. inset_rects[3]);
  228. }
  229. // Non intersecting rects
  230. {
  231. std::vector<PositionScaleDrawImage> images =
  232. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1000, 1000));
  233. EXPECT_EQ(0u, images.size());
  234. }
  235. {
  236. std::vector<PositionScaleDrawImage> images =
  237. GetDiscardableImagesInRect(image_map, gfx::Rect(3500, 0, 1000, 1000));
  238. EXPECT_EQ(0u, images.size());
  239. }
  240. {
  241. std::vector<PositionScaleDrawImage> images =
  242. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 1100, 1000, 1000));
  243. EXPECT_EQ(0u, images.size());
  244. }
  245. {
  246. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  247. image_map, gfx::Rect(3500, 1100, 1000, 1000));
  248. EXPECT_EQ(0u, images.size());
  249. }
  250. // Image not present in the list.
  251. {
  252. PaintImage image = CreateDiscardablePaintImage(gfx::Size(500, 500));
  253. EXPECT_EQ(image_map.GetRectsForImage(image.stable_id())->size(), 0u);
  254. }
  255. }
  256. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectOnePixelQuery) {
  257. gfx::Rect visible_rect(2048, 2048);
  258. FakeContentLayerClient content_layer_client;
  259. content_layer_client.set_bounds(visible_rect.size());
  260. // Discardable pixel refs are found in the following grids:
  261. // |---|---|---|---|
  262. // | | x | | x |
  263. // |---|---|---|---|
  264. // | x | | x | |
  265. // |---|---|---|---|
  266. // | | x | | x |
  267. // |---|---|---|---|
  268. // | x | | x | |
  269. // |---|---|---|---|
  270. PaintImage discardable_image[4][4];
  271. for (int y = 0; y < 4; ++y) {
  272. for (int x = 0; x < 4; ++x) {
  273. if ((x + y) & 1) {
  274. discardable_image[y][x] =
  275. CreateDiscardablePaintImage(gfx::Size(500, 500));
  276. content_layer_client.add_draw_image(
  277. discardable_image[y][x], gfx::Point(x * 512 + 6, y * 512 + 6));
  278. }
  279. }
  280. }
  281. scoped_refptr<DisplayItemList> display_list =
  282. content_layer_client.PaintContentsToDisplayList();
  283. display_list->GenerateDiscardableImagesMetadata();
  284. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  285. for (int y = 0; y < 4; ++y) {
  286. for (int x = 0; x < 4; ++x) {
  287. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  288. image_map, gfx::Rect(x * 512 + 256, y * 512 + 256, 1, 1));
  289. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  290. if ((x + y) & 1) {
  291. EXPECT_EQ(1u, images.size()) << x << " " << y;
  292. EXPECT_TRUE(images[0].image == discardable_image[y][x])
  293. << x << " " << y;
  294. EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
  295. inset_rects[0]);
  296. } else {
  297. EXPECT_EQ(0u, images.size()) << x << " " << y;
  298. }
  299. }
  300. }
  301. }
  302. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMassiveImage) {
  303. gfx::Rect visible_rect(2048, 2048);
  304. FakeContentLayerClient content_layer_client;
  305. content_layer_client.set_bounds(visible_rect.size());
  306. PaintImage discardable_image =
  307. CreateDiscardablePaintImage(gfx::Size(1 << 25, 1 << 25), nullptr,
  308. false /* allocate_encoded_memory */);
  309. content_layer_client.add_draw_image(discardable_image, gfx::Point(0, 0));
  310. scoped_refptr<DisplayItemList> display_list =
  311. content_layer_client.PaintContentsToDisplayList();
  312. display_list->GenerateDiscardableImagesMetadata();
  313. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  314. std::vector<PositionScaleDrawImage> images =
  315. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
  316. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  317. EXPECT_EQ(1u, images.size());
  318. EXPECT_TRUE(images[0].image == discardable_image);
  319. EXPECT_EQ(gfx::Rect(0, 0, 2048, 2048), inset_rects[0]);
  320. }
  321. TEST_F(DiscardableImageMapTest, PaintDestroyedWhileImageIsDrawn) {
  322. gfx::Rect visible_rect(2048, 2048);
  323. FakeContentLayerClient content_layer_client;
  324. content_layer_client.set_bounds(visible_rect.size());
  325. PaintImage discardable_image = CreateDiscardablePaintImage(gfx::Size(10, 10));
  326. sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
  327. scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
  328. PaintFlags paint;
  329. display_list->StartPaint();
  330. SkRect visible_sk_rect(gfx::RectToSkRect(visible_rect));
  331. display_list->push<SaveLayerOp>(&visible_sk_rect, &paint);
  332. display_list->push<DrawRecordOp>(std::move(record));
  333. display_list->push<RestoreOp>();
  334. display_list->EndPaintOfUnpaired(visible_rect);
  335. display_list->Finalize();
  336. display_list->GenerateDiscardableImagesMetadata();
  337. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  338. std::vector<PositionScaleDrawImage> images =
  339. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
  340. EXPECT_EQ(1u, images.size());
  341. EXPECT_TRUE(images[0].image == discardable_image);
  342. }
  343. // Check if SkNoDrawCanvas does not crash for large layers.
  344. TEST_F(DiscardableImageMapTest, RestoreSavedBigLayers) {
  345. PaintFlags flags;
  346. SkRect rect =
  347. SkRect::MakeWH(static_cast<float>(INT_MAX), static_cast<float>(INT_MAX));
  348. scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
  349. display_list->StartPaint();
  350. display_list->push<DrawRectOp>(rect, flags);
  351. display_list->EndPaintOfUnpaired(gfx::Rect(INT_MAX, INT_MAX));
  352. display_list->Finalize();
  353. display_list->GenerateDiscardableImagesMetadata();
  354. }
  355. // Test if SaveLayer and Restore work together.
  356. // 1. Move cursor to (25, 25) draw a black rect of size 25x25.
  357. // 2. save layer, move the cursor by (100, 100) or to point (125, 125), draw a
  358. // red rect of size 25x25.
  359. // 3. Restore layer, so the cursor moved back to (25, 25), move cursor by (100,
  360. // 0) or at the point (125, 25), draw a yellow rect of size 25x25.
  361. // (25, 25)
  362. // +---+
  363. // | |
  364. // +---+
  365. // (25, 125) (125, 125)
  366. // +---+ +---+
  367. // | | | |
  368. // +---+ +---+
  369. TEST_F(DiscardableImageMapTest, RestoreSavedTransformedLayers) {
  370. scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
  371. PaintFlags paint;
  372. gfx::Rect visible_rect(200, 200);
  373. display_list->StartPaint();
  374. PaintImage discardable_image1 =
  375. CreateDiscardablePaintImage(gfx::Size(25, 25));
  376. PaintImage discardable_image2 =
  377. CreateDiscardablePaintImage(gfx::Size(25, 25));
  378. PaintImage discardable_image3 =
  379. CreateDiscardablePaintImage(gfx::Size(25, 25));
  380. display_list->push<TranslateOp>(25.0f, 25.0f);
  381. display_list->push<DrawImageOp>(discardable_image1, 0.f, 0.f);
  382. display_list->push<SaveLayerOp>(nullptr, &paint);
  383. display_list->push<TranslateOp>(100.0f, 100.0f);
  384. display_list->push<DrawImageOp>(discardable_image2, 0.f, 0.f);
  385. display_list->push<RestoreOp>();
  386. display_list->push<TranslateOp>(0.0f, 100.0f);
  387. display_list->push<DrawImageOp>(discardable_image3, 0.f, 0.f);
  388. display_list->EndPaintOfUnpaired(visible_rect);
  389. display_list->Finalize();
  390. display_list->GenerateDiscardableImagesMetadata();
  391. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  392. std::vector<PositionScaleDrawImage> images =
  393. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 200, 200));
  394. EXPECT_EQ(3u, images.size());
  395. EXPECT_EQ(gfx::Rect(25, 25, 25, 25), InsetImageRects(images)[0]);
  396. EXPECT_EQ(gfx::Rect(125, 125, 25, 25), InsetImageRects(images)[1]);
  397. EXPECT_EQ(gfx::Rect(25, 125, 25, 25), InsetImageRects(images)[2]);
  398. }
  399. TEST_F(DiscardableImageMapTest, NullPaintOnSaveLayer) {
  400. gfx::Rect visible_rect(2048, 2048);
  401. FakeContentLayerClient content_layer_client;
  402. content_layer_client.set_bounds(visible_rect.size());
  403. PaintImage discardable_image = CreateDiscardablePaintImage(gfx::Size(10, 10));
  404. sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
  405. scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
  406. display_list->StartPaint();
  407. SkRect visible_sk_rect(gfx::RectToSkRect(visible_rect));
  408. display_list->push<SaveLayerOp>(&visible_sk_rect, nullptr);
  409. display_list->push<DrawRecordOp>(std::move(record));
  410. display_list->push<RestoreOp>();
  411. display_list->EndPaintOfUnpaired(visible_rect);
  412. display_list->Finalize();
  413. display_list->GenerateDiscardableImagesMetadata();
  414. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  415. std::vector<PositionScaleDrawImage> images =
  416. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
  417. EXPECT_EQ(1u, images.size());
  418. EXPECT_TRUE(images[0].image == discardable_image);
  419. }
  420. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMaxImage) {
  421. gfx::Rect visible_rect(2048, 2048);
  422. FakeContentLayerClient content_layer_client;
  423. content_layer_client.set_bounds(visible_rect.size());
  424. int dimension = std::numeric_limits<int>::max();
  425. sk_sp<SkColorSpace> no_color_space;
  426. PaintImage discardable_image = CreateDiscardablePaintImage(
  427. gfx::Size(dimension, dimension), no_color_space,
  428. false /* allocate_encoded_memory */);
  429. content_layer_client.add_draw_image(discardable_image, gfx::Point(42, 42));
  430. scoped_refptr<DisplayItemList> display_list =
  431. content_layer_client.PaintContentsToDisplayList();
  432. display_list->GenerateDiscardableImagesMetadata();
  433. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  434. std::vector<PositionScaleDrawImage> images =
  435. GetDiscardableImagesInRect(image_map, gfx::Rect(42, 42, 1, 1));
  436. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  437. EXPECT_EQ(1u, images.size());
  438. EXPECT_TRUE(images[0].image == discardable_image);
  439. EXPECT_EQ(gfx::Rect(42, 42, 2006, 2006), inset_rects[0]);
  440. }
  441. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMaxImageMaxLayer) {
  442. // At large values of integer x, x != static_cast<int>(static_cast<float>(x)).
  443. // So, make sure the dimension can be converted back and forth for the
  444. // purposes of the unittest. Also, at near max int values, Skia seems to skip
  445. // some draw calls, so we subtract 64 since we only care about "really large"
  446. // values, not necessarily max int values.
  447. int dimension = static_cast<int>(
  448. static_cast<float>(std::numeric_limits<int>::max() - 64));
  449. gfx::Rect visible_rect(dimension, dimension);
  450. FakeContentLayerClient content_layer_client;
  451. content_layer_client.set_bounds(visible_rect.size());
  452. sk_sp<SkColorSpace> no_color_space;
  453. PaintImage discardable_image1 = CreateDiscardablePaintImage(
  454. gfx::Size(dimension, dimension), no_color_space,
  455. false /* allocate_encoded_memory */);
  456. PaintImage discardable_image2 = CreateDiscardablePaintImage(
  457. gfx::Size(dimension, dimension), no_color_space,
  458. false /* allocate_encoded_memory */);
  459. PaintImage discardable_image3 = CreateDiscardablePaintImage(
  460. gfx::Size(dimension, dimension), no_color_space,
  461. false /* allocate_encoded_memory */);
  462. content_layer_client.add_draw_image(discardable_image1, gfx::Point(0, 0));
  463. content_layer_client.add_draw_image(discardable_image2, gfx::Point(10000, 0));
  464. content_layer_client.add_draw_image(discardable_image3,
  465. gfx::Point(-10000, 500));
  466. scoped_refptr<DisplayItemList> display_list =
  467. content_layer_client.PaintContentsToDisplayList();
  468. display_list->GenerateDiscardableImagesMetadata();
  469. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  470. std::vector<PositionScaleDrawImage> images =
  471. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
  472. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  473. EXPECT_EQ(1u, images.size());
  474. EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
  475. images = GetDiscardableImagesInRect(image_map, gfx::Rect(10000, 0, 1, 1));
  476. inset_rects = InsetImageRects(images);
  477. EXPECT_EQ(2u, images.size());
  478. EXPECT_EQ(gfx::Rect(10000, 0, dimension - 10000, dimension), inset_rects[1]);
  479. EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
  480. // Since we adjust negative offsets before using ToEnclosingRect, the expected
  481. // width will be converted to float, which means that we lose some precision.
  482. // The expected value is whatever the value is converted to float and then
  483. // back to int.
  484. int expected10k = static_cast<int>(static_cast<float>(dimension - 10000));
  485. images = GetDiscardableImagesInRect(image_map, gfx::Rect(0, 500, 1, 1));
  486. inset_rects = InsetImageRects(images);
  487. EXPECT_EQ(2u, images.size());
  488. EXPECT_EQ(gfx::Rect(0, 500, expected10k, dimension - 500), inset_rects[1]);
  489. EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
  490. }
  491. TEST_F(DiscardableImageMapTest, GetDiscardableImagesRectInBounds) {
  492. gfx::Rect visible_rect(1000, 1000);
  493. FakeContentLayerClient content_layer_client;
  494. content_layer_client.set_bounds(visible_rect.size());
  495. PaintImage discardable_image1 =
  496. CreateDiscardablePaintImage(gfx::Size(100, 100));
  497. PaintImage discardable_image2 =
  498. CreateDiscardablePaintImage(gfx::Size(100, 100));
  499. PaintImage long_discardable_image =
  500. CreateDiscardablePaintImage(gfx::Size(10000, 100));
  501. content_layer_client.add_draw_image(discardable_image1, gfx::Point(-10, -11));
  502. content_layer_client.add_draw_image(discardable_image2, gfx::Point(950, 951));
  503. content_layer_client.add_draw_image(long_discardable_image,
  504. gfx::Point(-100, 500));
  505. scoped_refptr<DisplayItemList> display_list =
  506. content_layer_client.PaintContentsToDisplayList();
  507. display_list->GenerateDiscardableImagesMetadata();
  508. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  509. std::vector<PositionScaleDrawImage> images =
  510. GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
  511. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  512. ASSERT_EQ(1u, images.size());
  513. EXPECT_EQ(gfx::Rect(0, 0, 90, 89), inset_rects[0]);
  514. images = GetDiscardableImagesInRect(image_map, gfx::Rect(999, 999, 1, 1));
  515. inset_rects = InsetImageRects(images);
  516. ASSERT_EQ(1u, images.size());
  517. EXPECT_EQ(gfx::Rect(950, 951, 50, 49), inset_rects[0]);
  518. images = GetDiscardableImagesInRect(image_map, gfx::Rect(0, 500, 1, 1));
  519. inset_rects = InsetImageRects(images);
  520. ASSERT_EQ(1u, images.size());
  521. EXPECT_EQ(gfx::Rect(0, 500, 1000, 100), inset_rects[0]);
  522. }
  523. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInShader) {
  524. gfx::Rect visible_rect(2048, 2048);
  525. FakeContentLayerClient content_layer_client;
  526. content_layer_client.set_bounds(visible_rect.size());
  527. // Discardable pixel refs are found in the following grids:
  528. // |---|---|---|---|
  529. // | | x | | x |
  530. // |---|---|---|---|
  531. // | x | | x | |
  532. // |---|---|---|---|
  533. // | | x | | x |
  534. // |---|---|---|---|
  535. // | x | | x | |
  536. // |---|---|---|---|
  537. PaintImage discardable_image[4][4];
  538. // Skia doesn't allow shader instantiation with non-invertible local
  539. // transforms, so we can't let the scale drop all the way to 0.
  540. static constexpr float kMinScale = 0.1f;
  541. for (int y = 0; y < 4; ++y) {
  542. for (int x = 0; x < 4; ++x) {
  543. if ((x + y) & 1) {
  544. discardable_image[y][x] =
  545. PaintImageBuilder::WithDefault()
  546. .set_id(y * 4 + x)
  547. .set_paint_image_generator(
  548. CreatePaintImageGenerator(gfx::Size(500, 500)))
  549. .TakePaintImage();
  550. SkMatrix scale = SkMatrix::Scale(std::max(x * 0.5f, kMinScale),
  551. std::max(y * 0.5f, kMinScale));
  552. PaintFlags flags;
  553. flags.setShader(PaintShader::MakeImage(discardable_image[y][x],
  554. SkTileMode::kClamp,
  555. SkTileMode::kClamp, &scale));
  556. content_layer_client.add_draw_rect(
  557. gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500), flags);
  558. }
  559. }
  560. }
  561. scoped_refptr<DisplayItemList> display_list =
  562. content_layer_client.PaintContentsToDisplayList();
  563. display_list->GenerateDiscardableImagesMetadata();
  564. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  565. for (int y = 0; y < 4; ++y) {
  566. for (int x = 0; x < 4; ++x) {
  567. std::vector<const DrawImage*> draw_images;
  568. image_map.GetDiscardableImagesInRect(
  569. gfx::Rect(x * 512, y * 512, 500, 500), &draw_images);
  570. if ((x + y) & 1) {
  571. EXPECT_EQ(1u, draw_images.size()) << x << " " << y;
  572. EXPECT_TRUE(draw_images[0]->paint_image() == discardable_image[y][x])
  573. << x << " " << y;
  574. EXPECT_EQ(std::max(x * 0.5f, kMinScale),
  575. draw_images[0]->scale().fWidth);
  576. EXPECT_EQ(std::max(y * 0.5f, kMinScale),
  577. draw_images[0]->scale().fHeight);
  578. } else {
  579. EXPECT_EQ(0u, draw_images.size()) << x << " " << y;
  580. }
  581. }
  582. }
  583. // Capture 4 pixel refs.
  584. std::vector<const DrawImage*> draw_images;
  585. image_map.GetDiscardableImagesInRect(gfx::Rect(512, 512, 2048, 2048),
  586. &draw_images);
  587. EXPECT_EQ(4u, draw_images.size());
  588. EXPECT_TRUE(draw_images[0]->paint_image() == discardable_image[1][2]);
  589. EXPECT_TRUE(draw_images[1]->paint_image() == discardable_image[2][1]);
  590. EXPECT_TRUE(draw_images[2]->paint_image() == discardable_image[2][3]);
  591. EXPECT_TRUE(draw_images[3]->paint_image() == discardable_image[3][2]);
  592. }
  593. TEST_F(DiscardableImageMapTest, ClipsImageRects) {
  594. gfx::Rect visible_rect(500, 500);
  595. PaintImage discardable_image =
  596. CreateDiscardablePaintImage(gfx::Size(500, 500));
  597. sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
  598. scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
  599. display_list->StartPaint();
  600. display_list->push<ClipRectOp>(gfx::RectToSkRect(gfx::Rect(250, 250)),
  601. SkClipOp::kIntersect, false);
  602. display_list->push<DrawRecordOp>(std::move(record));
  603. display_list->EndPaintOfUnpaired(gfx::Rect(250, 250));
  604. display_list->Finalize();
  605. display_list->GenerateDiscardableImagesMetadata();
  606. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  607. std::vector<PositionScaleDrawImage> images =
  608. GetDiscardableImagesInRect(image_map, visible_rect);
  609. std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
  610. EXPECT_EQ(1u, images.size());
  611. EXPECT_TRUE(images[0].image == discardable_image);
  612. EXPECT_EQ(gfx::Rect(250, 250), inset_rects[0]);
  613. }
  614. TEST_F(DiscardableImageMapTest, GathersDiscardableImagesFromNestedOps) {
  615. // This |discardable_image| is in a PaintOpBuffer that gets added to
  616. // the root buffer.
  617. auto internal_record = sk_make_sp<PaintOpBuffer>();
  618. PaintImage discardable_image =
  619. CreateDiscardablePaintImage(gfx::Size(100, 100));
  620. internal_record->push<DrawImageOp>(discardable_image, 0.f, 0.f);
  621. // This |discardable_image2| is in a DisplayItemList that gets added
  622. // to the root buffer.
  623. PaintImage discardable_image2 =
  624. CreateDiscardablePaintImage(gfx::Size(100, 100));
  625. scoped_refptr<DisplayItemList> display_list =
  626. new DisplayItemList(DisplayItemList::kToBeReleasedAsPaintOpBuffer);
  627. display_list->StartPaint();
  628. display_list->push<DrawImageOp>(discardable_image2, 100.f, 100.f);
  629. display_list->EndPaintOfUnpaired(gfx::Rect(100, 100, 100, 100));
  630. display_list->Finalize();
  631. sk_sp<PaintRecord> record2 = display_list->ReleaseAsRecord();
  632. PaintOpBuffer root_buffer;
  633. root_buffer.push<DrawRecordOp>(internal_record);
  634. root_buffer.push<DrawRecordOp>(record2);
  635. DiscardableImageMap image_map;
  636. image_map.Generate(&root_buffer, gfx::Rect(200, 200));
  637. std::vector<const DrawImage*> images;
  638. image_map.GetDiscardableImagesInRect(gfx::Rect(0, 0, 5, 95), &images);
  639. EXPECT_EQ(1u, images.size());
  640. EXPECT_TRUE(discardable_image == images[0]->paint_image());
  641. images.clear();
  642. image_map.GetDiscardableImagesInRect(gfx::Rect(105, 105, 5, 95), &images);
  643. EXPECT_EQ(1u, images.size());
  644. EXPECT_TRUE(discardable_image2 == images[0]->paint_image());
  645. }
  646. TEST_F(DiscardableImageMapTest, GathersAnimatedImages) {
  647. gfx::Rect visible_rect(1000, 1000);
  648. FakeContentLayerClient content_layer_client;
  649. content_layer_client.set_bounds(visible_rect.size());
  650. std::vector<FrameMetadata> frames = {
  651. FrameMetadata(true, base::Milliseconds(2)),
  652. FrameMetadata(true, base::Milliseconds(3))};
  653. gfx::Size image_size(100, 100);
  654. PaintImage static_image = CreateDiscardablePaintImage(image_size);
  655. PaintImage animated_loop_none =
  656. CreateAnimatedImage(image_size, frames, kAnimationNone);
  657. PaintImage animation_loop_infinite =
  658. CreateAnimatedImage(image_size, frames, 1u);
  659. content_layer_client.add_draw_image(static_image, gfx::Point(0, 0));
  660. content_layer_client.add_draw_image(animated_loop_none, gfx::Point(100, 100));
  661. content_layer_client.add_draw_image(animation_loop_infinite,
  662. gfx::Point(200, 200));
  663. scoped_refptr<DisplayItemList> display_list =
  664. content_layer_client.PaintContentsToDisplayList();
  665. display_list->GenerateDiscardableImagesMetadata();
  666. const auto& animated_images_metadata =
  667. display_list->discardable_image_map().animated_images_metadata();
  668. ASSERT_EQ(animated_images_metadata.size(), 1u);
  669. EXPECT_EQ(animated_images_metadata[0].paint_image_id,
  670. animation_loop_infinite.stable_id());
  671. EXPECT_EQ(animated_images_metadata[0].completion_state,
  672. animation_loop_infinite.completion_state());
  673. EXPECT_EQ(animated_images_metadata[0].frames,
  674. animation_loop_infinite.GetFrameMetadata());
  675. EXPECT_EQ(animated_images_metadata[0].repetition_count,
  676. animation_loop_infinite.repetition_count());
  677. std::vector<const DrawImage*> images;
  678. display_list->discardable_image_map().GetDiscardableImagesInRect(visible_rect,
  679. &images);
  680. ASSERT_EQ(images.size(), 3u);
  681. EXPECT_EQ(images[0]->paint_image(), static_image);
  682. EXPECT_DCHECK_DEATH(images[0]->frame_index());
  683. EXPECT_EQ(images[1]->paint_image(), animated_loop_none);
  684. EXPECT_DCHECK_DEATH(images[1]->frame_index());
  685. EXPECT_EQ(images[2]->paint_image(), animation_loop_infinite);
  686. EXPECT_DCHECK_DEATH(images[2]->frame_index());
  687. }
  688. TEST_F(DiscardableImageMapTest, GathersPaintWorklets) {
  689. gfx::Rect visible_rect(1000, 1000);
  690. FakeContentLayerClient content_layer_client;
  691. content_layer_client.set_bounds(visible_rect.size());
  692. gfx::Size image_size(100, 100);
  693. PaintImage static_image = CreateDiscardablePaintImage(image_size);
  694. scoped_refptr<TestPaintWorkletInput> input =
  695. base::MakeRefCounted<TestPaintWorkletInput>(gfx::SizeF(image_size));
  696. PaintImage paint_worklet_image = CreatePaintWorkletPaintImage(input);
  697. content_layer_client.add_draw_image(static_image, gfx::Point(0, 0));
  698. content_layer_client.add_draw_image(paint_worklet_image,
  699. gfx::Point(100, 100));
  700. scoped_refptr<DisplayItemList> display_list =
  701. content_layer_client.PaintContentsToDisplayList();
  702. display_list->GenerateDiscardableImagesMetadata();
  703. const auto& paint_worklet_inputs =
  704. display_list->discardable_image_map().paint_worklet_inputs();
  705. ASSERT_EQ(paint_worklet_inputs.size(), 1u);
  706. EXPECT_EQ(paint_worklet_inputs[0].first, input);
  707. // PaintWorklets are not considered discardable images.
  708. std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
  709. display_list->discardable_image_map(), visible_rect);
  710. ASSERT_EQ(images.size(), 1u);
  711. EXPECT_EQ(images[0].image, static_image);
  712. }
  713. TEST_F(DiscardableImageMapTest, CapturesImagesInPaintRecordShaders) {
  714. // Create the record to use in the shader.
  715. auto shader_record = sk_make_sp<PaintOpBuffer>();
  716. shader_record->push<ScaleOp>(2.0f, 2.0f);
  717. PaintImage static_image = CreateDiscardablePaintImage(gfx::Size(100, 100));
  718. shader_record->push<DrawImageOp>(static_image, 0.f, 0.f);
  719. std::vector<FrameMetadata> frames = {
  720. FrameMetadata(true, base::Milliseconds(1)),
  721. FrameMetadata(true, base::Milliseconds(1))};
  722. PaintImage animated_image = CreateAnimatedImage(gfx::Size(100, 100), frames);
  723. shader_record->push<DrawImageOp>(animated_image, 0.f, 0.f);
  724. gfx::Rect visible_rect(500, 500);
  725. scoped_refptr<DisplayItemList> display_list = new DisplayItemList();
  726. display_list->StartPaint();
  727. display_list->push<ScaleOp>(2.0f, 2.0f);
  728. PaintFlags flags;
  729. SkRect tile = SkRect::MakeWH(100, 100);
  730. flags.setShader(PaintShader::MakePaintRecord(
  731. shader_record, tile, SkTileMode::kClamp, SkTileMode::kClamp, nullptr));
  732. display_list->push<DrawRectOp>(SkRect::MakeWH(200, 200), flags);
  733. display_list->EndPaintOfUnpaired(visible_rect);
  734. display_list->Finalize();
  735. EXPECT_EQ(flags.getShader()->image_analysis_state(),
  736. ImageAnalysisState::kNoAnalysis);
  737. display_list->GenerateDiscardableImagesMetadata();
  738. EXPECT_EQ(flags.getShader()->image_analysis_state(),
  739. ImageAnalysisState::kAnimatedImages);
  740. const auto& image_map = display_list->discardable_image_map();
  741. // The image rect is set to the rect for the DrawRectOp, and only animated
  742. // images in a shader are tracked.
  743. std::vector<PositionScaleDrawImage> draw_images =
  744. GetDiscardableImagesInRect(image_map, visible_rect);
  745. std::vector<gfx::Rect> inset_rects = InsetImageRects(draw_images);
  746. ASSERT_EQ(draw_images.size(), 1u);
  747. EXPECT_EQ(draw_images[0].image, animated_image);
  748. // The position of the image is the position of the DrawRectOp that uses the
  749. // shader.
  750. EXPECT_EQ(gfx::Rect(400, 400), inset_rects[0]);
  751. // The scale of the image includes the scale at which the shader record is
  752. // rasterized.
  753. EXPECT_EQ(SkSize::Make(4.f, 4.f), draw_images[0].scale);
  754. }
  755. TEST_F(DiscardableImageMapTest, CapturesImagesInPaintFilters) {
  756. // Create the record to use in the filter.
  757. auto filter_record = sk_make_sp<PaintOpBuffer>();
  758. PaintImage static_image = CreateDiscardablePaintImage(gfx::Size(100, 100));
  759. filter_record->push<DrawImageOp>(static_image, 0.f, 0.f);
  760. std::vector<FrameMetadata> frames = {
  761. FrameMetadata(true, base::Milliseconds(1)),
  762. FrameMetadata(true, base::Milliseconds(1))};
  763. PaintImage animated_image = CreateAnimatedImage(gfx::Size(100, 100), frames);
  764. filter_record->push<DrawImageOp>(animated_image, 0.f, 0.f);
  765. gfx::Rect visible_rect(500, 500);
  766. scoped_refptr<DisplayItemList> display_list = new DisplayItemList();
  767. display_list->StartPaint();
  768. PaintFlags flags;
  769. flags.setImageFilter(sk_make_sp<RecordPaintFilter>(
  770. filter_record, SkRect::MakeWH(150.f, 150.f)));
  771. display_list->push<DrawRectOp>(SkRect::MakeWH(200, 200), flags);
  772. display_list->EndPaintOfUnpaired(visible_rect);
  773. display_list->Finalize();
  774. EXPECT_EQ(flags.getImageFilter()->image_analysis_state(),
  775. ImageAnalysisState::kNoAnalysis);
  776. display_list->GenerateDiscardableImagesMetadata();
  777. EXPECT_EQ(flags.getImageFilter()->image_analysis_state(),
  778. ImageAnalysisState::kAnimatedImages);
  779. const auto& image_map = display_list->discardable_image_map();
  780. // The image rect is set to the rect for the DrawRectOp, and only animated
  781. // images in a filter are tracked.
  782. std::vector<PositionScaleDrawImage> draw_images =
  783. GetDiscardableImagesInRect(image_map, visible_rect);
  784. std::vector<gfx::Rect> inset_rects = InsetImageRects(draw_images);
  785. ASSERT_EQ(draw_images.size(), 1u);
  786. EXPECT_EQ(draw_images[0].image, animated_image);
  787. // The position of the image is the position of the DrawRectOp that uses the
  788. // filter. Since the bounds of the filter does not depend on the source/input,
  789. // the resulting bounds is that of the RecordPaintFilter.
  790. EXPECT_EQ(gfx::Rect(150, 150), inset_rects[0]);
  791. // Images in a filter are decoded at the original size.
  792. EXPECT_EQ(SkSize::Make(1.f, 1.f), draw_images[0].scale);
  793. }
  794. TEST_F(DiscardableImageMapTest, CapturesImagesInSaveLayers) {
  795. PaintFlags flags;
  796. PaintImage image = CreateDiscardablePaintImage(gfx::Size(100, 100));
  797. flags.setShader(PaintShader::MakeImage(image, SkTileMode::kClamp,
  798. SkTileMode::kClamp, nullptr));
  799. gfx::Rect visible_rect(500, 500);
  800. scoped_refptr<DisplayItemList> display_list = new DisplayItemList();
  801. display_list->StartPaint();
  802. display_list->push<SaveLayerOp>(nullptr, &flags);
  803. display_list->push<DrawColorOp>(SkColors::kBlue, SkBlendMode::kSrc);
  804. display_list->EndPaintOfUnpaired(visible_rect);
  805. display_list->Finalize();
  806. display_list->GenerateDiscardableImagesMetadata();
  807. const auto& image_map = display_list->discardable_image_map();
  808. std::vector<PositionScaleDrawImage> draw_images =
  809. GetDiscardableImagesInRect(image_map, visible_rect);
  810. std::vector<gfx::Rect> inset_rects = InsetImageRects(draw_images);
  811. ASSERT_EQ(draw_images.size(), 1u);
  812. EXPECT_EQ(draw_images[0].image, image);
  813. EXPECT_EQ(gfx::Rect(500, 500), inset_rects[0]);
  814. EXPECT_EQ(SkSize::Make(1.f, 1.f), draw_images[0].scale);
  815. }
  816. TEST_F(DiscardableImageMapTest, EmbeddedShaderWithAnimatedImages) {
  817. // Create the record with animated image to use in the shader.
  818. SkRect tile = SkRect::MakeWH(100, 100);
  819. auto shader_record = sk_make_sp<PaintOpBuffer>();
  820. std::vector<FrameMetadata> frames = {
  821. FrameMetadata(true, base::Milliseconds(1)),
  822. FrameMetadata(true, base::Milliseconds(1))};
  823. PaintImage animated_image = CreateAnimatedImage(gfx::Size(100, 100), frames);
  824. shader_record->push<DrawImageOp>(animated_image, 0.f, 0.f);
  825. auto shader_with_image = PaintShader::MakePaintRecord(
  826. shader_record, tile, SkTileMode::kClamp, SkTileMode::kClamp, nullptr);
  827. // Create a second shader which uses the shader above.
  828. auto second_shader_record = sk_make_sp<PaintOpBuffer>();
  829. PaintFlags flags;
  830. flags.setShader(shader_with_image);
  831. second_shader_record->push<DrawRectOp>(SkRect::MakeWH(200, 200), flags);
  832. auto shader_with_shader_with_image = PaintShader::MakePaintRecord(
  833. second_shader_record, tile, SkTileMode::kClamp, SkTileMode::kClamp,
  834. nullptr);
  835. gfx::Rect visible_rect(500, 500);
  836. scoped_refptr<DisplayItemList> display_list = new DisplayItemList();
  837. display_list->StartPaint();
  838. flags.setShader(shader_with_shader_with_image);
  839. display_list->push<DrawRectOp>(SkRect::MakeWH(200, 200), flags);
  840. display_list->EndPaintOfUnpaired(visible_rect);
  841. display_list->Finalize();
  842. display_list->GenerateDiscardableImagesMetadata();
  843. EXPECT_EQ(shader_with_image->image_analysis_state(),
  844. ImageAnalysisState::kAnimatedImages);
  845. EXPECT_EQ(shader_with_shader_with_image->image_analysis_state(),
  846. ImageAnalysisState::kAnimatedImages);
  847. }
  848. TEST_F(DiscardableImageMapTest, DecodingModeHintsBasic) {
  849. gfx::Rect visible_rect(100, 100);
  850. PaintImage unspecified_image =
  851. PaintImageBuilder::WithCopy(
  852. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  853. .set_id(1)
  854. .set_decoding_mode(PaintImage::DecodingMode::kUnspecified)
  855. .TakePaintImage();
  856. PaintImage async_image =
  857. PaintImageBuilder::WithCopy(
  858. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  859. .set_id(2)
  860. .set_decoding_mode(PaintImage::DecodingMode::kAsync)
  861. .TakePaintImage();
  862. PaintImage sync_image =
  863. PaintImageBuilder::WithCopy(
  864. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  865. .set_id(3)
  866. .set_decoding_mode(PaintImage::DecodingMode::kSync)
  867. .TakePaintImage();
  868. FakeContentLayerClient content_layer_client;
  869. content_layer_client.set_bounds(visible_rect.size());
  870. content_layer_client.add_draw_image(unspecified_image, gfx::Point(0, 0));
  871. content_layer_client.add_draw_image(async_image, gfx::Point(10, 10));
  872. content_layer_client.add_draw_image(sync_image, gfx::Point(20, 20));
  873. scoped_refptr<DisplayItemList> display_list =
  874. content_layer_client.PaintContentsToDisplayList();
  875. display_list->GenerateDiscardableImagesMetadata();
  876. auto decode_hints = display_list->TakeDecodingModeMap();
  877. ASSERT_EQ(decode_hints.size(), 3u);
  878. ASSERT_TRUE(decode_hints.find(1) != decode_hints.end());
  879. ASSERT_TRUE(decode_hints.find(2) != decode_hints.end());
  880. ASSERT_TRUE(decode_hints.find(3) != decode_hints.end());
  881. EXPECT_EQ(decode_hints[1], PaintImage::DecodingMode::kUnspecified);
  882. EXPECT_EQ(decode_hints[2], PaintImage::DecodingMode::kAsync);
  883. EXPECT_EQ(decode_hints[3], PaintImage::DecodingMode::kSync);
  884. decode_hints = display_list->TakeDecodingModeMap();
  885. EXPECT_EQ(decode_hints.size(), 0u);
  886. }
  887. TEST_F(DiscardableImageMapTest, DecodingModeHintsDuplicates) {
  888. gfx::Rect visible_rect(100, 100);
  889. PaintImage unspecified_image1 =
  890. PaintImageBuilder::WithCopy(
  891. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  892. .set_id(1)
  893. .set_decoding_mode(PaintImage::DecodingMode::kUnspecified)
  894. .TakePaintImage();
  895. PaintImage async_image1 =
  896. PaintImageBuilder::WithCopy(
  897. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  898. .set_id(1)
  899. .set_decoding_mode(PaintImage::DecodingMode::kAsync)
  900. .TakePaintImage();
  901. PaintImage unspecified_image2 =
  902. PaintImageBuilder::WithCopy(
  903. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  904. .set_id(2)
  905. .set_decoding_mode(PaintImage::DecodingMode::kUnspecified)
  906. .TakePaintImage();
  907. PaintImage sync_image2 =
  908. PaintImageBuilder::WithCopy(
  909. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  910. .set_id(2)
  911. .set_decoding_mode(PaintImage::DecodingMode::kSync)
  912. .TakePaintImage();
  913. PaintImage async_image3 =
  914. PaintImageBuilder::WithCopy(
  915. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  916. .set_id(3)
  917. .set_decoding_mode(PaintImage::DecodingMode::kAsync)
  918. .TakePaintImage();
  919. PaintImage sync_image3 =
  920. PaintImageBuilder::WithCopy(
  921. CreateDiscardablePaintImage(gfx::Size(10, 10)))
  922. .set_id(3)
  923. .set_decoding_mode(PaintImage::DecodingMode::kSync)
  924. .TakePaintImage();
  925. FakeContentLayerClient content_layer_client;
  926. content_layer_client.set_bounds(visible_rect.size());
  927. content_layer_client.add_draw_image(unspecified_image1, gfx::Point(0, 0));
  928. content_layer_client.add_draw_image(async_image1, gfx::Point(10, 10));
  929. content_layer_client.add_draw_image(unspecified_image2, gfx::Point(20, 20));
  930. content_layer_client.add_draw_image(sync_image2, gfx::Point(30, 30));
  931. content_layer_client.add_draw_image(async_image3, gfx::Point(40, 40));
  932. content_layer_client.add_draw_image(sync_image3, gfx::Point(50, 50));
  933. scoped_refptr<DisplayItemList> display_list =
  934. content_layer_client.PaintContentsToDisplayList();
  935. display_list->GenerateDiscardableImagesMetadata();
  936. auto decode_hints = display_list->TakeDecodingModeMap();
  937. ASSERT_EQ(decode_hints.size(), 3u);
  938. ASSERT_TRUE(decode_hints.find(1) != decode_hints.end());
  939. ASSERT_TRUE(decode_hints.find(2) != decode_hints.end());
  940. ASSERT_TRUE(decode_hints.find(3) != decode_hints.end());
  941. // 1 was unspecified and async, so the result should be unspecified.
  942. EXPECT_EQ(decode_hints[1], PaintImage::DecodingMode::kUnspecified);
  943. // 2 was unspecified and sync, so the result should be sync.
  944. EXPECT_EQ(decode_hints[2], PaintImage::DecodingMode::kSync);
  945. // 3 was async and sync, so the result should be sync
  946. EXPECT_EQ(decode_hints[3], PaintImage::DecodingMode::kSync);
  947. decode_hints = display_list->TakeDecodingModeMap();
  948. EXPECT_EQ(decode_hints.size(), 0u);
  949. }
  950. TEST_F(DiscardableImageMapTest, TracksImageRegions) {
  951. gfx::Rect visible_rect(500, 500);
  952. FakeContentLayerClient content_layer_client;
  953. content_layer_client.set_bounds(visible_rect.size());
  954. std::vector<FrameMetadata> frames = {
  955. FrameMetadata(true, base::Milliseconds(1)),
  956. FrameMetadata(true, base::Milliseconds(1)),
  957. };
  958. auto image = CreateAnimatedImage(gfx::Size(100, 100), frames);
  959. content_layer_client.add_draw_image(image, gfx::Point(0, 0));
  960. content_layer_client.add_draw_image(image, gfx::Point(400, 400));
  961. scoped_refptr<DisplayItemList> display_list =
  962. content_layer_client.PaintContentsToDisplayList();
  963. display_list->GenerateDiscardableImagesMetadata();
  964. const auto& image_map = display_list->discardable_image_map();
  965. std::vector<gfx::Rect> rects = {gfx::Rect(100, 100),
  966. gfx::Rect(400, 400, 100, 100)};
  967. Region expected_region;
  968. for (auto& rect : rects) {
  969. rect.Inset(-1);
  970. expected_region.Union(rect);
  971. }
  972. EXPECT_EQ(ImageRectsToRegion(image_map.GetRectsForImage(image.stable_id())),
  973. expected_region);
  974. }
  975. TEST_F(DiscardableImageMapTest, HighBitDepth) {
  976. gfx::Rect visible_rect(500, 500);
  977. SkBitmap bitmap;
  978. auto info = SkImageInfo::Make(visible_rect.width(), visible_rect.height(),
  979. kRGBA_F16_SkColorType, kPremul_SkAlphaType,
  980. nullptr /* color_space */);
  981. bitmap.allocPixels(info);
  982. bitmap.eraseColor(SK_AlphaTRANSPARENT);
  983. PaintImage discardable_image = PaintImageBuilder::WithDefault()
  984. .set_id(PaintImage::GetNextId())
  985. .set_is_high_bit_depth(true)
  986. .set_image(SkImage::MakeFromBitmap(bitmap),
  987. PaintImage::GetNextContentId())
  988. .TakePaintImage();
  989. FakeContentLayerClient content_layer_client;
  990. content_layer_client.set_bounds(visible_rect.size());
  991. scoped_refptr<DisplayItemList> display_list =
  992. content_layer_client.PaintContentsToDisplayList();
  993. display_list->GenerateDiscardableImagesMetadata();
  994. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  995. EXPECT_FALSE(image_map.contains_hbd_images());
  996. content_layer_client.add_draw_image(discardable_image, gfx::Point(0, 0));
  997. display_list = content_layer_client.PaintContentsToDisplayList();
  998. display_list->GenerateDiscardableImagesMetadata();
  999. const DiscardableImageMap& image_map2 = display_list->discardable_image_map();
  1000. EXPECT_TRUE(image_map2.contains_hbd_images());
  1001. }
  1002. TEST_F(DiscardableImageMapTest, ContentColorUsage) {
  1003. constexpr gfx::Size kSize(25, 25);
  1004. constexpr gfx::Rect kVisibleRect(500, 500);
  1005. FakeContentLayerClient content_layer_client;
  1006. content_layer_client.set_bounds(kVisibleRect.size());
  1007. // Empty map should report a color usage of SRGB.
  1008. auto display_list = content_layer_client.PaintContentsToDisplayList();
  1009. display_list->GenerateDiscardableImagesMetadata();
  1010. EXPECT_EQ(display_list->discardable_image_map().content_color_usage(),
  1011. gfx::ContentColorUsage::kSRGB);
  1012. // Adding a SRGB image should remain SRGB.
  1013. PaintImage discardable_image_srgb = CreateDiscardablePaintImage(
  1014. kSize, gfx::ColorSpace::CreateSRGB().ToSkColorSpace());
  1015. content_layer_client.add_draw_image(discardable_image_srgb, gfx::Point(0, 0));
  1016. display_list = content_layer_client.PaintContentsToDisplayList();
  1017. display_list->GenerateDiscardableImagesMetadata();
  1018. EXPECT_EQ(display_list->discardable_image_map().content_color_usage(),
  1019. gfx::ContentColorUsage::kSRGB);
  1020. // Adding a WCG image should switch to WCG.
  1021. PaintImage discardable_image_wcg = CreateDiscardablePaintImage(
  1022. kSize, gfx::ColorSpace::CreateDisplayP3D65().ToSkColorSpace());
  1023. content_layer_client.add_draw_image(discardable_image_wcg, gfx::Point(0, 0));
  1024. display_list = content_layer_client.PaintContentsToDisplayList();
  1025. display_list->GenerateDiscardableImagesMetadata();
  1026. EXPECT_EQ(display_list->discardable_image_map().content_color_usage(),
  1027. gfx::ContentColorUsage::kWideColorGamut);
  1028. // Adding a HDR image should switch to HDR.
  1029. PaintImage discardable_image_hdr = CreateDiscardablePaintImage(
  1030. kSize, gfx::ColorSpace::CreateHDR10().ToSkColorSpace());
  1031. content_layer_client.add_draw_image(discardable_image_hdr, gfx::Point(0, 0));
  1032. display_list = content_layer_client.PaintContentsToDisplayList();
  1033. display_list->GenerateDiscardableImagesMetadata();
  1034. EXPECT_EQ(display_list->discardable_image_map().content_color_usage(),
  1035. gfx::ContentColorUsage::kHDR);
  1036. }
  1037. #if BUILDFLAG(SKIA_SUPPORT_SKOTTIE)
  1038. TEST_F(DiscardableImageMapTest,
  1039. GetDiscardableImagesInRectSkottieWithoutImages) {
  1040. gfx::Rect visible_rect(2048, 2048);
  1041. FakeContentLayerClient content_layer_client;
  1042. content_layer_client.set_bounds(visible_rect.size());
  1043. content_layer_client.add_draw_skottie(FakeContentLayerClient::SkottieData(
  1044. CreateSkottie(gfx::Size(2048, 2048), /*duration_secs=*/1.f),
  1045. /*dst=*/gfx::Rect(2048, 2048), /*t=*/0.1f, SkottieFrameDataMap(),
  1046. SkottieColorMap(), SkottieTextPropertyValueMap()));
  1047. scoped_refptr<DisplayItemList> display_list =
  1048. content_layer_client.PaintContentsToDisplayList();
  1049. display_list->GenerateDiscardableImagesMetadata();
  1050. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  1051. EXPECT_THAT(GetDiscardableImagesInRect(image_map, gfx::Rect(2048, 2048)),
  1052. IsEmpty());
  1053. }
  1054. TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectSkottieWithImages) {
  1055. gfx::Rect visible_rect(2048, 2048);
  1056. FakeContentLayerClient content_layer_client;
  1057. content_layer_client.set_bounds(visible_rect.size());
  1058. // Skottie animation only is rendered in the right half of the screen.
  1059. scoped_refptr<SkottieWrapper> skottie =
  1060. CreateSkottieFromString(kLottieDataWith2Assets);
  1061. SkottieFrameDataMap images_in;
  1062. PaintImage image_0 = CreateDiscardablePaintImage(
  1063. gfx::Size(kLottieDataWith2AssetsWidth, kLottieDataWith2AssetsHeight));
  1064. PaintImage image_1 = CreateDiscardablePaintImage(
  1065. gfx::Size(kLottieDataWith2AssetsWidth, kLottieDataWith2AssetsHeight));
  1066. images_in[HashSkottieResourceId("image_0")] = {
  1067. .image = image_0, .quality = PaintFlags::FilterQuality::kHigh};
  1068. images_in[HashSkottieResourceId("image_1")] = {
  1069. .image = image_1, .quality = PaintFlags::FilterQuality::kHigh};
  1070. content_layer_client.add_draw_skottie(FakeContentLayerClient::SkottieData(
  1071. CreateSkottieFromString(kLottieDataWith2Assets),
  1072. /*dst=*/gfx::Rect(1024, 0, 1024, 2048),
  1073. /*t=*/0.1f, images_in, SkottieColorMap(), SkottieTextPropertyValueMap()));
  1074. scoped_refptr<DisplayItemList> display_list =
  1075. content_layer_client.PaintContentsToDisplayList();
  1076. display_list->GenerateDiscardableImagesMetadata();
  1077. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  1078. // Left Half of screen should return no images.
  1079. EXPECT_THAT(GetDiscardableImagesInRect(image_map, gfx::Rect(1023, 2048)),
  1080. IsEmpty());
  1081. // Right Half of screen should return 2 images.
  1082. std::vector<PositionScaleDrawImage> images_out =
  1083. GetDiscardableImagesInRect(image_map, gfx::Rect(1024, 0, 1024, 2048));
  1084. ASSERT_THAT(images_out, SizeIs(2));
  1085. EXPECT_THAT(images_out,
  1086. Contains(Field(&PositionScaleDrawImage::image, Eq(image_0))));
  1087. EXPECT_THAT(images_out,
  1088. Contains(Field(&PositionScaleDrawImage::image, Eq(image_1))));
  1089. }
  1090. TEST_F(DiscardableImageMapTest,
  1091. GetDiscardableImagesInRectSkottieWithImagesScalesProperly) {
  1092. gfx::Rect visible_rect(kLottieDataWith2AssetsWidth * 2,
  1093. kLottieDataWith2AssetsHeight * 3);
  1094. FakeContentLayerClient content_layer_client;
  1095. content_layer_client.set_bounds(visible_rect.size());
  1096. scoped_refptr<SkottieWrapper> skottie =
  1097. CreateSkottieFromString(kLottieDataWith2Assets);
  1098. SkottieFrameDataMap images_in;
  1099. PaintImage image_0 = CreateDiscardablePaintImage(
  1100. gfx::Size(kLottieDataWith2AssetsWidth, kLottieDataWith2AssetsHeight));
  1101. PaintImage image_1 = CreateDiscardablePaintImage(
  1102. gfx::Size(kLottieDataWith2AssetsWidth, kLottieDataWith2AssetsHeight));
  1103. images_in[HashSkottieResourceId("image_0")] = {
  1104. .image = image_0, .quality = PaintFlags::FilterQuality::kHigh};
  1105. images_in[HashSkottieResourceId("image_1")] = {
  1106. .image = image_1, .quality = PaintFlags::FilterQuality::kHigh};
  1107. content_layer_client.add_draw_skottie(FakeContentLayerClient::SkottieData(
  1108. CreateSkottieFromString(kLottieDataWith2Assets),
  1109. /*dst=*/visible_rect,
  1110. /*t=*/0.1f, images_in, SkottieColorMap(), SkottieTextPropertyValueMap()));
  1111. scoped_refptr<DisplayItemList> display_list =
  1112. content_layer_client.PaintContentsToDisplayList();
  1113. display_list->GenerateDiscardableImagesMetadata();
  1114. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  1115. std::vector<PositionScaleDrawImage> images_out =
  1116. GetDiscardableImagesInRect(image_map, visible_rect);
  1117. ASSERT_THAT(images_out, SizeIs(2));
  1118. for (const PositionScaleDrawImage& image_out : images_out) {
  1119. static constexpr float kScaleTolerance = .01f;
  1120. EXPECT_THAT(image_out.scale.width(), FloatNear(2.f, kScaleTolerance));
  1121. // Even though the destination rect's height is 3x the animation frame's
  1122. // height, the image should not get stretched.
  1123. EXPECT_THAT(image_out.scale.height(), FloatNear(2.f, kScaleTolerance));
  1124. }
  1125. }
  1126. #endif // BUILDFLAG(SKIA_SUPPORT_SKOTTIE)
  1127. class DiscardableImageMapColorSpaceTest
  1128. : public DiscardableImageMapTest,
  1129. public testing::WithParamInterface<gfx::ColorSpace> {};
  1130. TEST_P(DiscardableImageMapColorSpaceTest, ColorSpace) {
  1131. const gfx::ColorSpace image_color_space = GetParam();
  1132. gfx::Rect visible_rect(500, 500);
  1133. PaintImage discardable_image = CreateDiscardablePaintImage(
  1134. gfx::Size(500, 500), image_color_space.ToSkColorSpace());
  1135. FakeContentLayerClient content_layer_client;
  1136. content_layer_client.set_bounds(visible_rect.size());
  1137. scoped_refptr<DisplayItemList> display_list =
  1138. content_layer_client.PaintContentsToDisplayList();
  1139. display_list->GenerateDiscardableImagesMetadata();
  1140. const DiscardableImageMap& image_map = display_list->discardable_image_map();
  1141. EXPECT_EQ(image_map.content_color_usage(), gfx::ContentColorUsage::kSRGB);
  1142. EXPECT_FALSE(image_map.contains_hbd_images());
  1143. content_layer_client.add_draw_image(discardable_image, gfx::Point(0, 0));
  1144. display_list = content_layer_client.PaintContentsToDisplayList();
  1145. display_list->GenerateDiscardableImagesMetadata();
  1146. const DiscardableImageMap& image_map2 = display_list->discardable_image_map();
  1147. if (!image_color_space.IsValid()) {
  1148. EXPECT_EQ(image_map2.content_color_usage(), gfx::ContentColorUsage::kSRGB);
  1149. } else if (image_color_space == gfx::ColorSpace::CreateSRGB()) {
  1150. EXPECT_EQ(image_map2.content_color_usage(), gfx::ContentColorUsage::kSRGB);
  1151. } else if (image_color_space.IsHDR()) {
  1152. EXPECT_EQ(image_map2.content_color_usage(), gfx::ContentColorUsage::kHDR);
  1153. } else {
  1154. EXPECT_EQ(image_map2.content_color_usage(),
  1155. gfx::ContentColorUsage::kWideColorGamut);
  1156. }
  1157. }
  1158. gfx::ColorSpace test_color_spaces[] = {
  1159. gfx::ColorSpace(), gfx::ColorSpace::CreateSRGB(),
  1160. gfx::ColorSpace::CreateDisplayP3D65(), gfx::ColorSpace::CreateHDR10(),
  1161. gfx::ColorSpace::CreateHLG()};
  1162. INSTANTIATE_TEST_SUITE_P(ColorSpace,
  1163. DiscardableImageMapColorSpaceTest,
  1164. testing::ValuesIn(test_color_spaces));
  1165. } // namespace cc