ui_resource_layer_impl_unittest.cc 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. // Copyright 2013 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/layers/ui_resource_layer_impl.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "cc/layers/append_quads_data.h"
  8. #include "cc/resources/ui_resource_bitmap.h"
  9. #include "cc/resources/ui_resource_client.h"
  10. #include "cc/test/fake_impl_task_runner_provider.h"
  11. #include "cc/test/fake_layer_tree_frame_sink.h"
  12. #include "cc/test/fake_layer_tree_host_impl.h"
  13. #include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
  14. #include "cc/test/layer_tree_impl_test_base.h"
  15. #include "cc/test/test_task_graph_runner.h"
  16. #include "cc/trees/single_thread_proxy.h"
  17. #include "components/viz/common/quads/draw_quad.h"
  18. #include "testing/gmock/include/gmock/gmock.h"
  19. #include "testing/gtest/include/gtest/gtest.h"
  20. #include "ui/gfx/geometry/transform.h"
  21. namespace cc {
  22. namespace {
  23. UIResourceLayerImpl* GenerateUIResourceLayer(
  24. FakeUIResourceLayerTreeHostImpl* host_impl,
  25. const gfx::Size& bitmap_size,
  26. const gfx::Size& layer_size,
  27. bool opaque,
  28. UIResourceId uid) {
  29. gfx::Rect visible_layer_rect(layer_size);
  30. std::unique_ptr<UIResourceLayerImpl> layer =
  31. UIResourceLayerImpl::Create(host_impl->active_tree(), 1);
  32. layer->draw_properties().visible_layer_rect = visible_layer_rect;
  33. layer->SetBounds(layer_size);
  34. UIResourceBitmap bitmap(bitmap_size, opaque);
  35. host_impl->CreateUIResource(uid, bitmap);
  36. layer->SetUIResourceId(uid);
  37. host_impl->active_tree()->property_trees()->clear();
  38. auto* layer_ptr = layer.get();
  39. SetupRootProperties(layer_ptr);
  40. host_impl->active_tree()->SetRootLayerForTesting(std::move(layer));
  41. UpdateDrawProperties(host_impl->active_tree());
  42. return layer_ptr;
  43. }
  44. void QuadSizeTest(FakeUIResourceLayerTreeHostImpl* host_impl,
  45. UIResourceLayerImpl* layer,
  46. size_t expected_quad_size) {
  47. auto render_pass = viz::CompositorRenderPass::Create();
  48. AppendQuadsData data;
  49. host_impl->active_tree()->root_layer()->AppendQuads(render_pass.get(), &data);
  50. // Verify quad rects
  51. const viz::QuadList& quads = render_pass->quad_list;
  52. EXPECT_EQ(expected_quad_size, quads.size());
  53. host_impl->active_tree()->DetachLayers();
  54. }
  55. TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
  56. FakeImplTaskRunnerProvider task_runner_provider;
  57. TestTaskGraphRunner task_graph_runner;
  58. std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
  59. FakeLayerTreeFrameSink::Create3d();
  60. FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
  61. &task_graph_runner);
  62. host_impl.SetVisible(true);
  63. host_impl.InitializeFrameSink(layer_tree_frame_sink.get());
  64. // Make sure we're appending quads when there are valid values.
  65. gfx::Size bitmap_size(100, 100);
  66. gfx::Size layer_size(100, 100);
  67. size_t expected_quad_size = 1;
  68. bool opaque = true;
  69. UIResourceId uid = 1;
  70. auto* layer =
  71. GenerateUIResourceLayer(&host_impl, bitmap_size, layer_size, opaque, uid);
  72. QuadSizeTest(&host_impl, layer, expected_quad_size);
  73. host_impl.DeleteUIResource(uid);
  74. // Make sure we're not appending quads when there are invalid values.
  75. expected_quad_size = 0;
  76. uid = 0;
  77. layer = GenerateUIResourceLayer(&host_impl,
  78. bitmap_size,
  79. layer_size,
  80. opaque,
  81. uid);
  82. QuadSizeTest(&host_impl, layer, expected_quad_size);
  83. host_impl.DeleteUIResource(uid);
  84. }
  85. void NeedsBlendingTest(FakeUIResourceLayerTreeHostImpl* host_impl,
  86. UIResourceLayerImpl* layer,
  87. bool needs_blending) {
  88. auto render_pass = viz::CompositorRenderPass::Create();
  89. AppendQuadsData data;
  90. host_impl->active_tree()->root_layer()->AppendQuads(render_pass.get(), &data);
  91. // Verify needs_blending is set appropriately.
  92. const viz::QuadList& quads = render_pass->quad_list;
  93. EXPECT_GE(quads.size(), (size_t)0);
  94. EXPECT_EQ(needs_blending, quads.front()->needs_blending);
  95. EXPECT_EQ(quads.front()->needs_blending,
  96. !quads.front()->shared_quad_state->are_contents_opaque);
  97. host_impl->active_tree()->DetachLayers();
  98. }
  99. TEST(UIResourceLayerImplTest, VerifySetOpaqueOnSkBitmap) {
  100. FakeImplTaskRunnerProvider task_runner_provider;
  101. TestTaskGraphRunner task_graph_runner;
  102. std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
  103. FakeLayerTreeFrameSink::Create3d();
  104. FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
  105. &task_graph_runner);
  106. host_impl.SetVisible(true);
  107. host_impl.InitializeFrameSink(layer_tree_frame_sink.get());
  108. gfx::Size bitmap_size(100, 100);
  109. gfx::Size layer_size(100, 100);
  110. bool opaque = false;
  111. UIResourceId uid = 1;
  112. auto* layer =
  113. GenerateUIResourceLayer(&host_impl, bitmap_size, layer_size, opaque, uid);
  114. NeedsBlendingTest(&host_impl, layer, !opaque);
  115. host_impl.DeleteUIResource(uid);
  116. opaque = true;
  117. layer = GenerateUIResourceLayer(&host_impl,
  118. bitmap_size,
  119. layer_size,
  120. opaque,
  121. uid);
  122. NeedsBlendingTest(&host_impl, layer, !opaque);
  123. host_impl.DeleteUIResource(uid);
  124. }
  125. TEST(UIResourceLayerImplTest, VerifySetOpaqueOnLayer) {
  126. FakeImplTaskRunnerProvider task_runner_provider;
  127. TestTaskGraphRunner task_graph_runner;
  128. std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
  129. FakeLayerTreeFrameSink::Create3d();
  130. FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
  131. &task_graph_runner);
  132. host_impl.SetVisible(true);
  133. host_impl.InitializeFrameSink(layer_tree_frame_sink.get());
  134. gfx::Size bitmap_size(100, 100);
  135. gfx::Size layer_size(100, 100);
  136. bool skbitmap_opaque = false;
  137. UIResourceId uid = 1;
  138. auto* layer = GenerateUIResourceLayer(&host_impl, bitmap_size, layer_size,
  139. skbitmap_opaque, uid);
  140. bool opaque = false;
  141. layer->SetContentsOpaque(opaque);
  142. NeedsBlendingTest(&host_impl, layer, !opaque);
  143. host_impl.DeleteUIResource(uid);
  144. opaque = true;
  145. layer = GenerateUIResourceLayer(
  146. &host_impl, bitmap_size, layer_size, skbitmap_opaque, uid);
  147. layer->SetContentsOpaque(true);
  148. NeedsBlendingTest(&host_impl, layer, !opaque);
  149. host_impl.DeleteUIResource(uid);
  150. }
  151. TEST(UIResourceLayerImplTest, Occlusion) {
  152. gfx::Size layer_size(1000, 1000);
  153. gfx::Size viewport_size(1000, 1000);
  154. LayerTreeImplTestBase impl;
  155. SkBitmap sk_bitmap;
  156. sk_bitmap.allocN32Pixels(10, 10);
  157. sk_bitmap.setImmutable();
  158. UIResourceId uid = 5;
  159. UIResourceBitmap bitmap(sk_bitmap);
  160. impl.host_impl()->CreateUIResource(uid, bitmap);
  161. UIResourceLayerImpl* ui_resource_layer_impl =
  162. impl.AddLayer<UIResourceLayerImpl>();
  163. ui_resource_layer_impl->SetBounds(layer_size);
  164. ui_resource_layer_impl->SetDrawsContent(true);
  165. ui_resource_layer_impl->SetUIResourceId(uid);
  166. CopyProperties(impl.root_layer(), ui_resource_layer_impl);
  167. impl.CalcDrawProps(viewport_size);
  168. {
  169. SCOPED_TRACE("No occlusion");
  170. gfx::Rect occluded;
  171. impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
  172. VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect(layer_size));
  173. EXPECT_EQ(1u, impl.quad_list().size());
  174. }
  175. {
  176. SCOPED_TRACE("Full occlusion");
  177. gfx::Rect occluded(ui_resource_layer_impl->visible_layer_rect());
  178. impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
  179. VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
  180. EXPECT_EQ(impl.quad_list().size(), 0u);
  181. }
  182. {
  183. SCOPED_TRACE("Partial occlusion");
  184. gfx::Rect occluded(200, 0, 800, 1000);
  185. impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
  186. size_t partially_occluded_count = 0;
  187. VerifyQuadsAreOccluded(impl.quad_list(), occluded,
  188. &partially_occluded_count);
  189. // The layer outputs one quad, which is partially occluded.
  190. EXPECT_EQ(1u, impl.quad_list().size());
  191. EXPECT_EQ(1u, partially_occluded_count);
  192. }
  193. }
  194. } // namespace
  195. } // namespace cc