render_surface_unittest.cc 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264
  1. // Copyright 2011 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/append_quads_data.h"
  5. #include "cc/layers/layer_impl.h"
  6. #include "cc/layers/render_surface_impl.h"
  7. #include "cc/test/fake_impl_task_runner_provider.h"
  8. #include "cc/test/fake_layer_tree_frame_sink.h"
  9. #include "cc/test/fake_layer_tree_host_impl.h"
  10. #include "cc/test/fake_picture_layer_impl.h"
  11. #include "cc/test/layer_tree_impl_test_base.h"
  12. #include "cc/test/mock_occlusion_tracker.h"
  13. #include "cc/test/test_task_graph_runner.h"
  14. #include "cc/trees/layer_tree_impl.h"
  15. #include "cc/trees/single_thread_proxy.h"
  16. #include "components/viz/common/quads/shared_quad_state.h"
  17. #include "components/viz/common/quads/tile_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. #include "base/memory/ptr_util.h"
  22. #include "cc/test/fake_raster_source.h"
  23. namespace cc {
  24. namespace {
  25. #define EXECUTE_AND_VERIFY_SURFACE_CHANGED(code_to_test) \
  26. render_surface->ResetPropertyChangedFlags(); \
  27. code_to_test; \
  28. EXPECT_TRUE(render_surface->SurfacePropertyChanged())
  29. #define EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(code_to_test) \
  30. render_surface->ResetPropertyChangedFlags(); \
  31. code_to_test; \
  32. EXPECT_FALSE(render_surface->SurfacePropertyChanged())
  33. // The AppendQuads method of this class generates multiple quads and one of them
  34. // does not intersect with visible_layer_rect.
  35. class FakePictureLayerImplForRenderSurfaceTest : public FakePictureLayerImpl {
  36. public:
  37. static std::unique_ptr<FakePictureLayerImplForRenderSurfaceTest> Create(
  38. LayerTreeImpl* tree_impl,
  39. int id) {
  40. return base::WrapUnique(
  41. new FakePictureLayerImplForRenderSurfaceTest(tree_impl, id));
  42. }
  43. std::unique_ptr<LayerImpl> CreateLayerImpl(
  44. LayerTreeImpl* tree_impl) const override {
  45. return base::WrapUnique(
  46. new FakePictureLayerImplForRenderSurfaceTest(tree_impl, id()));
  47. }
  48. void SetQuadRectsForTesting(std::vector<gfx::Rect> quad_rects) {
  49. quad_rects_ = quad_rects;
  50. }
  51. bool HasValidTilePriorities() const override { return false; }
  52. void AppendQuads(viz::CompositorRenderPass* render_pass,
  53. AppendQuadsData* append_quads_data) override {
  54. viz::SharedQuadState* shared_quad_state =
  55. render_pass->CreateAndAppendSharedQuadState();
  56. float max_contents_scale = 1.f;
  57. PopulateScaledSharedQuadState(shared_quad_state, max_contents_scale,
  58. contents_opaque());
  59. bool needs_blending = false;
  60. for (const auto& rect : quad_rects_) {
  61. auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
  62. quad->SetNew(shared_quad_state, rect, rect, needs_blending,
  63. viz::kInvalidResourceId, gfx::RectF(rect), bounds(), false,
  64. false, false);
  65. }
  66. }
  67. protected:
  68. FakePictureLayerImplForRenderSurfaceTest(LayerTreeImpl* tree_impl, int id)
  69. : FakePictureLayerImpl(tree_impl, id) {}
  70. std::vector<gfx::Rect> quad_rects_;
  71. };
  72. TEST(RenderSurfaceTest, VerifySurfaceChangesAreTrackedProperly) {
  73. //
  74. // This test checks that SurfacePropertyChanged() has the correct behavior.
  75. //
  76. LayerTreeImplTestBase impl;
  77. LayerImpl* root = impl.root_layer();
  78. LayerTreeImpl* active_tree = impl.host_impl()->active_tree();
  79. LayerImpl* layer = impl.AddLayer<LayerImpl>();
  80. CopyProperties(root, layer);
  81. CreateEffectNode(layer).render_surface_reason = RenderSurfaceReason::kTest;
  82. UpdateDrawProperties(active_tree);
  83. gfx::Rect test_rect(3, 4, 5, 6);
  84. active_tree->ResetAllChangeTracking();
  85. RenderSurfaceImpl* render_surface = GetRenderSurface(layer);
  86. ASSERT_TRUE(render_surface);
  87. // Currently, the content_rect, clip_rect, and
  88. // owning_layer->layerPropertyChanged() are the only sources of change.
  89. EXECUTE_AND_VERIFY_SURFACE_CHANGED(render_surface->SetClipRect(test_rect));
  90. EXECUTE_AND_VERIFY_SURFACE_CHANGED(
  91. render_surface->SetContentRectForTesting(test_rect));
  92. active_tree->SetOpacityMutated(root->element_id(), 0.5f);
  93. EXPECT_TRUE(render_surface->SurfacePropertyChanged());
  94. active_tree->ResetAllChangeTracking();
  95. // Setting the surface properties to the same values again should not be
  96. // considered "change".
  97. EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(
  98. render_surface->SetClipRect(test_rect));
  99. EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(
  100. render_surface->SetContentRectForTesting(test_rect));
  101. constexpr int kArbitraryLayerId = 200;
  102. std::unique_ptr<LayerImpl> dummy_mask =
  103. LayerImpl::Create(active_tree, kArbitraryLayerId);
  104. gfx::Transform dummy_matrix;
  105. dummy_matrix.Translate(1.0, 2.0);
  106. // The rest of the surface properties are either internal and should not cause
  107. // change, or they are already accounted for by the
  108. // owninglayer->layerPropertyChanged().
  109. EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(
  110. render_surface->SetDrawOpacity(0.5f));
  111. EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(
  112. render_surface->SetDrawTransform(dummy_matrix));
  113. }
  114. TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectSharedQuadState) {
  115. LayerTreeImplTestBase impl;
  116. LayerImpl* root = impl.root_layer();
  117. LayerImpl* layer = impl.AddLayer<LayerImpl>();
  118. CopyProperties(root, layer);
  119. auto& effect_node = CreateEffectNode(layer);
  120. effect_node.render_surface_reason = RenderSurfaceReason::kBlendMode;
  121. SkBlendMode blend_mode = SkBlendMode::kSoftLight;
  122. effect_node.blend_mode = blend_mode;
  123. UpdateDrawProperties(impl.host_impl()->active_tree());
  124. RenderSurfaceImpl* render_surface = GetRenderSurface(layer);
  125. ASSERT_TRUE(render_surface);
  126. gfx::Rect content_rect(0, 0, 50, 50);
  127. gfx::Rect clip_rect(5, 5, 40, 40);
  128. gfx::Transform origin;
  129. origin.Translate(30, 40);
  130. render_surface->SetContentRectForTesting(content_rect);
  131. render_surface->SetClipRect(clip_rect);
  132. render_surface->SetDrawOpacity(1.f);
  133. render_surface->SetDrawTransform(origin);
  134. auto render_pass = viz::CompositorRenderPass::Create();
  135. AppendQuadsData append_quads_data;
  136. render_surface->AppendQuads(DRAW_MODE_HARDWARE, render_pass.get(),
  137. &append_quads_data);
  138. ASSERT_EQ(1u, render_pass->shared_quad_state_list.size());
  139. viz::SharedQuadState* shared_quad_state =
  140. render_pass->shared_quad_state_list.front();
  141. EXPECT_EQ(30.0,
  142. shared_quad_state->quad_to_target_transform.matrix().rc(0, 3));
  143. EXPECT_EQ(40.0,
  144. shared_quad_state->quad_to_target_transform.matrix().rc(1, 3));
  145. EXPECT_EQ(content_rect,
  146. gfx::Rect(shared_quad_state->visible_quad_layer_rect));
  147. EXPECT_EQ(1.f, shared_quad_state->opacity);
  148. EXPECT_EQ(blend_mode, shared_quad_state->blend_mode);
  149. }
  150. TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectRenderPass) {
  151. LayerTreeImplTestBase impl;
  152. LayerImpl* root = impl.root_layer();
  153. LayerImpl* layer = impl.AddLayer<LayerImpl>();
  154. CopyProperties(root, layer);
  155. auto& effect_node = CreateEffectNode(layer);
  156. effect_node.render_surface_reason = RenderSurfaceReason::kTest;
  157. UpdateDrawProperties(impl.host_impl()->active_tree());
  158. RenderSurfaceImpl* render_surface = GetRenderSurface(layer);
  159. ASSERT_TRUE(render_surface);
  160. gfx::Rect content_rect(0, 0, 50, 50);
  161. gfx::Transform origin;
  162. origin.Translate(30.0, 40.0);
  163. render_surface->SetScreenSpaceTransform(origin);
  164. render_surface->SetContentRectForTesting(content_rect);
  165. auto pass = render_surface->CreateRenderPass();
  166. EXPECT_EQ(viz::CompositorRenderPassId{2}, pass->id);
  167. EXPECT_EQ(content_rect, pass->output_rect);
  168. EXPECT_EQ(origin, pass->transform_to_root_target);
  169. }
  170. TEST(RenderSurfaceTest, SanityCheckSurfaceIgnoreMaskLayerOcclusion) {
  171. LayerTreeImplTestBase impl;
  172. LayerImpl* root = impl.root_layer();
  173. // Set a big enough viewport to show the entire render pass.
  174. impl.host_impl()->active_tree()->SetDeviceViewportRect(gfx::Rect(1000, 1000));
  175. auto* layer = impl.AddLayer<LayerImpl>();
  176. layer->SetBounds(gfx::Size(200, 100));
  177. layer->SetDrawsContent(true);
  178. CopyProperties(root, layer);
  179. CreateEffectNode(layer);
  180. auto* mask_layer = impl.AddLayer<FakePictureLayerImplForRenderSurfaceTest>();
  181. scoped_refptr<FakeRasterSource> raster_source(
  182. FakeRasterSource::CreateFilled(mask_layer->bounds()));
  183. mask_layer->SetRasterSource(raster_source, Region());
  184. std::vector<gfx::Rect> quad_rects;
  185. quad_rects.push_back(gfx::Rect(0, 0, 100, 100));
  186. quad_rects.push_back(gfx::Rect(100, 0, 100, 100));
  187. mask_layer->SetQuadRectsForTesting(quad_rects);
  188. SetupMaskProperties(layer, mask_layer);
  189. UpdateDrawProperties(impl.host_impl()->active_tree());
  190. RenderSurfaceImpl* render_surface = GetRenderSurface(layer);
  191. ASSERT_TRUE(render_surface);
  192. gfx::Rect content_rect(0, 0, 200, 100);
  193. gfx::Rect occluded(0, 0, 200, 100);
  194. render_surface->SetContentRectForTesting(content_rect);
  195. mask_layer->draw_properties().occlusion_in_content_space =
  196. Occlusion(gfx::Transform(), SimpleEnclosedRegion(occluded),
  197. SimpleEnclosedRegion(occluded));
  198. auto render_pass = viz::CompositorRenderPass::Create();
  199. AppendQuadsData append_quads_data;
  200. render_surface->AppendQuads(DRAW_MODE_HARDWARE, render_pass.get(),
  201. &append_quads_data);
  202. ASSERT_EQ(1u, render_pass->shared_quad_state_list.size());
  203. viz::SharedQuadState* shared_quad_state =
  204. render_pass->shared_quad_state_list.front();
  205. EXPECT_EQ(content_rect,
  206. gfx::Rect(shared_quad_state->visible_quad_layer_rect));
  207. ASSERT_EQ(1u, render_pass->quad_list.size());
  208. EXPECT_EQ(gfx::Rect(0, 0, 200, 100).ToString(),
  209. render_pass->quad_list.front()->rect.ToString());
  210. }
  211. } // namespace
  212. } // namespace cc