1 // Copyright 2012 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.
5 #include "cc/layers/delegated_renderer_layer_impl.h"
7 #include "cc/base/scoped_ptr_vector.h"
8 #include "cc/layers/solid_color_layer_impl.h"
9 #include "cc/quads/render_pass_draw_quad.h"
10 #include "cc/quads/solid_color_draw_quad.h"
11 #include "cc/test/fake_delegated_renderer_layer_impl.h"
12 #include "cc/test/fake_impl_proxy.h"
13 #include "cc/test/fake_layer_tree_host_impl.h"
14 #include "cc/test/fake_layer_tree_host_impl_client.h"
15 #include "cc/test/fake_output_surface.h"
16 #include "cc/test/geometry_test_utils.h"
17 #include "cc/test/layer_test_common.h"
18 #include "cc/test/render_pass_test_utils.h"
19 #include "cc/test/test_shared_bitmap_manager.h"
20 #include "cc/test/test_task_graph_runner.h"
21 #include "cc/test/test_web_graphics_context_3d.h"
22 #include "cc/trees/layer_tree_host_impl.h"
23 #include "cc/trees/layer_tree_impl.h"
24 #include "cc/trees/single_thread_proxy.h"
25 #include "testing/gtest/include/gtest/gtest.h"
26 #include "ui/gfx/transform.h"
31 class DelegatedRendererLayerImplTest
: public testing::Test
{
33 DelegatedRendererLayerImplTest()
35 always_impl_thread_and_main_thread_blocked_(&proxy_
),
36 output_surface_(FakeOutputSurface::Create3d()) {
37 LayerTreeSettings settings
;
38 settings
.minimum_occlusion_tracking_size
= gfx::Size();
40 host_impl_
.reset(new FakeLayerTreeHostImpl(
41 settings
, &proxy_
, &shared_bitmap_manager_
, &task_graph_runner_
));
42 host_impl_
->InitializeRenderer(output_surface_
.get());
43 host_impl_
->SetViewportSize(gfx::Size(10, 10));
48 DebugScopedSetImplThreadAndMainThreadBlocked
49 always_impl_thread_and_main_thread_blocked_
;
50 TestSharedBitmapManager shared_bitmap_manager_
;
51 TestTaskGraphRunner task_graph_runner_
;
52 scoped_ptr
<OutputSurface
> output_surface_
;
53 scoped_ptr
<LayerTreeHostImpl
> host_impl_
;
56 class DelegatedRendererLayerImplTestSimple
57 : public DelegatedRendererLayerImplTest
{
59 DelegatedRendererLayerImplTestSimple()
60 : DelegatedRendererLayerImplTest() {
61 scoped_ptr
<LayerImpl
> root_layer
=
62 SolidColorLayerImpl::Create(host_impl_
->active_tree(), 1);
63 scoped_ptr
<LayerImpl
> layer_before
=
64 SolidColorLayerImpl::Create(host_impl_
->active_tree(), 2);
65 scoped_ptr
<LayerImpl
> layer_after
=
66 SolidColorLayerImpl::Create(host_impl_
->active_tree(), 3);
67 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer
=
68 FakeDelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 4);
70 host_impl_
->SetViewportSize(gfx::Size(100, 100));
71 root_layer
->SetBounds(gfx::Size(100, 100));
72 root_layer
->SetHasRenderSurface(true);
74 layer_before
->SetPosition(gfx::Point(20, 20));
75 layer_before
->SetBounds(gfx::Size(14, 14));
76 layer_before
->SetDrawsContent(true);
77 layer_before
->SetHasRenderSurface(true);
79 layer_after
->SetPosition(gfx::Point(5, 5));
80 layer_after
->SetBounds(gfx::Size(15, 15));
81 layer_after
->SetDrawsContent(true);
82 layer_after
->SetHasRenderSurface(true);
84 delegated_renderer_layer
->SetPosition(gfx::Point(3, 3));
85 delegated_renderer_layer
->SetBounds(gfx::Size(10, 10));
86 delegated_renderer_layer
->SetDrawsContent(true);
87 gfx::Transform transform
;
88 transform
.Translate(1.0, 1.0);
89 delegated_renderer_layer
->SetTransform(transform
);
91 RenderPassList delegated_render_passes
;
93 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 6),
94 gfx::Rect(6, 6, 6, 6), gfx::Transform(1, 0, 0, 1, 5, 6));
95 AddQuad(pass1
, gfx::Rect(0, 0, 6, 6), 33u);
97 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 7),
98 gfx::Rect(7, 7, 7, 7), gfx::Transform(1, 0, 0, 1, 7, 8));
99 AddQuad(pass2
, gfx::Rect(0, 0, 7, 7), 22u);
100 AddRenderPassQuad(pass2
, pass1
);
102 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 8),
103 gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
104 AddRenderPassQuad(pass3
, pass2
);
105 delegated_renderer_layer
->SetFrameDataForRenderPasses(
106 1.f
, delegated_render_passes
);
108 root_layer_
= root_layer
.get();
109 layer_before_
= layer_before
.get();
110 layer_after_
= layer_after
.get();
111 delegated_renderer_layer_
= delegated_renderer_layer
.get();
113 // Force the delegated RenderPasses to come before the RenderPass from
115 layer_after
->AddChild(delegated_renderer_layer
.Pass());
116 root_layer
->AddChild(layer_after
.Pass());
118 // Get the RenderPass generated by layer_before to come before the delegated
120 root_layer
->AddChild(layer_before
.Pass());
121 host_impl_
->active_tree()->SetRootLayer(root_layer
.Pass());
125 LayerImpl
* root_layer_
;
126 LayerImpl
* layer_before_
;
127 LayerImpl
* layer_after_
;
128 DelegatedRendererLayerImpl
* delegated_renderer_layer_
;
131 TEST_F(DelegatedRendererLayerImplTest
,
132 ChangeContributingRenderPassForNewFrame
) {
133 FakeDelegatedRendererLayerImpl
* fake_delegated_renderer_layer_impl
;
135 scoped_ptr
<LayerImpl
> root_layer
=
136 SolidColorLayerImpl::Create(host_impl_
->active_tree(), 1);
137 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer
=
138 FakeDelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 2);
140 host_impl_
->SetViewportSize(gfx::Size(100, 100));
141 root_layer
->SetBounds(gfx::Size(100, 100));
142 root_layer
->SetHasRenderSurface(true);
144 delegated_renderer_layer
->SetPosition(gfx::Point(3, 3));
145 delegated_renderer_layer
->SetBounds(gfx::Size(10, 10));
146 delegated_renderer_layer
->SetDrawsContent(true);
147 delegated_renderer_layer
->SetHasRenderSurface(true);
148 gfx::Transform transform
;
149 transform
.Translate(1.0, 1.0);
150 delegated_renderer_layer
->SetTransform(transform
);
152 RenderPassList delegated_render_passes
;
154 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 6),
155 gfx::Rect(6, 6, 6, 6), gfx::Transform(1, 0, 0, 1, 5, 6));
156 AddQuad(pass1
, gfx::Rect(0, 0, 6, 6), 33u);
158 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 7),
159 gfx::Rect(7, 7, 7, 7), gfx::Transform(1, 0, 0, 1, 7, 8));
160 AddQuad(pass2
, gfx::Rect(0, 0, 7, 7), 22u);
161 AddRenderPassQuad(pass2
, pass1
);
163 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 8),
164 gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
165 AddRenderPassQuad(pass3
, pass2
);
166 delegated_renderer_layer
->SetFrameDataForRenderPasses(
167 1.f
, delegated_render_passes
);
169 fake_delegated_renderer_layer_impl
= delegated_renderer_layer
.get();
171 root_layer
->AddChild(delegated_renderer_layer
.Pass());
173 host_impl_
->active_tree()->SetRootLayer(root_layer
.Pass());
175 LayerTreeHostImpl::FrameData frame
;
176 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
178 // Root layer has one render pass, and delegated renderer layer has two
179 // contributing render passes and its own render pass.
180 ASSERT_EQ(4u, frame
.render_passes
.size());
182 host_impl_
->DrawLayers(&frame
);
183 host_impl_
->DidDrawAllLayers(frame
);
186 // New frame makes delegated renderer layer loses its contributing render
188 RenderPassList delegated_render_passes
;
189 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 8),
190 gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
191 fake_delegated_renderer_layer_impl
->SetFrameDataForRenderPasses(
192 1.f
, delegated_render_passes
);
194 // Force damage to redraw a new frame.
195 host_impl_
->SetViewportDamage(gfx::Rect(10, 10));
197 LayerTreeHostImpl::FrameData frame
;
198 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
200 // Each non-DelegatedRendererLayer added one RenderPass. The
201 // DelegatedRendererLayer added two contributing passes.
202 ASSERT_EQ(1u, frame
.render_passes
.size());
204 host_impl_
->DrawLayers(&frame
);
205 host_impl_
->DidDrawAllLayers(frame
);
209 TEST_F(DelegatedRendererLayerImplTest
,
210 ChangeContributingRenderPassNonFullTreeSync
) {
211 FakeDelegatedRendererLayerImpl
* fake_delegated_renderer_layer_impl
;
213 host_impl_
->CreatePendingTree();
214 scoped_ptr
<LayerImpl
> root_layer
=
215 SolidColorLayerImpl::Create(host_impl_
->pending_tree(), 1);
216 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer
=
217 FakeDelegatedRendererLayerImpl::Create(host_impl_
->pending_tree(), 2);
219 host_impl_
->SetViewportSize(gfx::Size(100, 100));
220 root_layer
->SetBounds(gfx::Size(100, 100));
221 root_layer
->SetHasRenderSurface(true);
223 delegated_renderer_layer
->SetPosition(gfx::Point(3, 3));
224 delegated_renderer_layer
->SetBounds(gfx::Size(10, 10));
225 delegated_renderer_layer
->SetDrawsContent(true);
226 delegated_renderer_layer
->SetHasRenderSurface(true);
227 gfx::Transform transform
;
228 transform
.Translate(1.0, 1.0);
229 delegated_renderer_layer
->SetTransform(transform
);
231 RenderPassList delegated_render_passes
;
233 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 6),
234 gfx::Rect(6, 6, 6, 6), gfx::Transform(1, 0, 0, 1, 5, 6));
235 AddQuad(pass1
, gfx::Rect(0, 0, 6, 6), 33u);
237 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 7),
238 gfx::Rect(7, 7, 7, 7), gfx::Transform(1, 0, 0, 1, 7, 8));
239 AddQuad(pass2
, gfx::Rect(0, 0, 7, 7), 22u);
240 AddRenderPassQuad(pass2
, pass1
);
242 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 8),
243 gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
244 AddRenderPassQuad(pass3
, pass2
);
245 delegated_renderer_layer
->SetFrameDataForRenderPasses(
246 1.f
, delegated_render_passes
);
248 fake_delegated_renderer_layer_impl
= delegated_renderer_layer
.get();
250 root_layer
->AddChild(delegated_renderer_layer
.Pass());
252 host_impl_
->pending_tree()->SetRootLayer(root_layer
.Pass());
253 host_impl_
->ActivateSyncTree();
255 LayerTreeHostImpl::FrameData frame
;
256 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
258 // Root layer has one render pass, and delegated renderer layer has two
259 // contributing render passes and its own render pass.
260 ASSERT_EQ(4u, frame
.render_passes
.size());
262 host_impl_
->DrawLayers(&frame
);
263 host_impl_
->DidDrawAllLayers(frame
);
266 // Remove contributing render passes from the delegated renderer layer.
267 host_impl_
->CreatePendingTree();
268 host_impl_
->pending_tree()->set_needs_full_tree_sync(false);
269 RenderPassList delegated_render_passes
;
270 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 8),
271 gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
273 fake_delegated_renderer_layer_impl
->SetFrameDataForRenderPasses(
274 1.f
, delegated_render_passes
);
276 // Force damage to redraw a new frame.
278 host_impl_
->ActivateSyncTree();
279 host_impl_
->SetViewportDamage(gfx::Rect(100, 100));
280 LayerTreeHostImpl::FrameData frame
;
281 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
283 // Root layer has one render pass, and delegated renderer layer no longer
284 // has contributing render passes.
285 ASSERT_EQ(1u, frame
.render_passes
.size());
287 host_impl_
->DrawLayers(&frame
);
288 host_impl_
->DidDrawAllLayers(frame
);
292 TEST_F(DelegatedRendererLayerImplTestSimple
, AddsContributingRenderPasses
) {
293 LayerTreeHostImpl::FrameData frame
;
294 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
296 // Each non-DelegatedRendererLayer added one RenderPass. The
297 // DelegatedRendererLayer added two contributing passes.
298 ASSERT_EQ(5u, frame
.render_passes
.size());
300 // The DelegatedRendererLayer should have added its contributing RenderPasses
302 EXPECT_EQ(4, frame
.render_passes
[1]->id
.layer_id
);
303 EXPECT_EQ(1u, frame
.render_passes
[1]->id
.index
);
304 EXPECT_EQ(4, frame
.render_passes
[2]->id
.layer_id
);
305 EXPECT_EQ(2u, frame
.render_passes
[2]->id
.index
);
306 // And all other RenderPasses should be non-delegated.
307 EXPECT_NE(4, frame
.render_passes
[0]->id
.layer_id
);
308 EXPECT_EQ(0u, frame
.render_passes
[0]->id
.index
);
309 EXPECT_NE(4, frame
.render_passes
[3]->id
.layer_id
);
310 EXPECT_EQ(0u, frame
.render_passes
[3]->id
.index
);
311 EXPECT_NE(4, frame
.render_passes
[4]->id
.layer_id
);
312 EXPECT_EQ(0u, frame
.render_passes
[4]->id
.index
);
314 // The DelegatedRendererLayer should have added its RenderPasses to the frame
316 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
317 frame
.render_passes
[1]->output_rect
.ToString());
318 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
319 frame
.render_passes
[2]->output_rect
.ToString());
321 host_impl_
->DrawLayers(&frame
);
322 host_impl_
->DidDrawAllLayers(frame
);
325 TEST_F(DelegatedRendererLayerImplTestSimple
,
326 AddsQuadsToContributingRenderPasses
) {
327 LayerTreeHostImpl::FrameData frame
;
328 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
330 // Each non-DelegatedRendererLayer added one RenderPass. The
331 // DelegatedRendererLayer added two contributing passes.
332 ASSERT_EQ(5u, frame
.render_passes
.size());
334 // The DelegatedRendererLayer should have added its contributing RenderPasses
336 EXPECT_EQ(4, frame
.render_passes
[1]->id
.layer_id
);
337 EXPECT_EQ(1u, frame
.render_passes
[1]->id
.index
);
338 EXPECT_EQ(4, frame
.render_passes
[2]->id
.layer_id
);
339 EXPECT_EQ(2u, frame
.render_passes
[2]->id
.index
);
341 // The DelegatedRendererLayer should have added copies of its quads to
342 // contributing RenderPasses.
343 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
344 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
345 frame
.render_passes
[1]->quad_list
.front()->rect
.ToString());
347 // Verify it added the right quads.
348 ASSERT_EQ(2u, frame
.render_passes
[2]->quad_list
.size());
349 EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
350 frame
.render_passes
[2]->quad_list
.front()->rect
.ToString());
351 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
352 frame
.render_passes
[2]->quad_list
.ElementAt(1)->rect
.ToString());
353 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
354 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
355 frame
.render_passes
[1]->quad_list
.front()->rect
.ToString());
357 host_impl_
->DrawLayers(&frame
);
358 host_impl_
->DidDrawAllLayers(frame
);
361 TEST_F(DelegatedRendererLayerImplTestSimple
, AddsQuadsToTargetRenderPass
) {
362 LayerTreeHostImpl::FrameData frame
;
363 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
365 // Each non-DelegatedRendererLayer added one RenderPass. The
366 // DelegatedRendererLayer added two contributing passes.
367 ASSERT_EQ(5u, frame
.render_passes
.size());
369 // The layer's target is the RenderPass from layer_after_.
370 EXPECT_EQ(RenderPassId(3, 0), frame
.render_passes
[3]->id
);
372 // The DelegatedRendererLayer should have added copies of quads in its root
373 // RenderPass to its target RenderPass. The layer_after_ also adds one quad.
374 ASSERT_EQ(2u, frame
.render_passes
[3]->quad_list
.size());
376 // Verify it added the right quads.
377 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
378 frame
.render_passes
[3]->quad_list
.front()->rect
.ToString());
380 // Its target layer should have a quad as well.
381 EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
382 frame
.render_passes
[3]->quad_list
.ElementAt(1)->rect
.ToString());
384 host_impl_
->DrawLayers(&frame
);
385 host_impl_
->DidDrawAllLayers(frame
);
388 TEST_F(DelegatedRendererLayerImplTestSimple
,
389 QuadsFromRootRenderPassAreModifiedForTheTarget
) {
390 LayerTreeHostImpl::FrameData frame
;
391 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
393 // Each non-DelegatedRendererLayer added one RenderPass. The
394 // DelegatedRendererLayer added two contributing passes.
395 ASSERT_EQ(5u, frame
.render_passes
.size());
397 // The DelegatedRendererLayer is at position 3,3 compared to its target, and
398 // has a translation transform of 1,1. So its root RenderPass' quads should
399 // all be transformed by that combined amount.
400 gfx::Transform transform
;
401 transform
.Translate(4.0, 4.0);
402 EXPECT_TRANSFORMATION_MATRIX_EQ(
403 transform
, frame
.render_passes
[3]
405 ->shared_quad_state
->quad_to_target_transform
);
407 // Quads from non-root RenderPasses should not be shifted though.
408 ASSERT_EQ(2u, frame
.render_passes
[2]->quad_list
.size());
410 EXPECT_TRANSFORMATION_MATRIX_EQ(
411 gfx::Transform(), frame
.render_passes
[2]
413 ->shared_quad_state
->quad_to_target_transform
);
414 EXPECT_TRANSFORMATION_MATRIX_EQ(
415 gfx::Transform(), frame
.render_passes
[2]
416 ->quad_list
.ElementAt(1)
417 ->shared_quad_state
->quad_to_target_transform
);
418 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
419 EXPECT_TRANSFORMATION_MATRIX_EQ(
420 gfx::Transform(), frame
.render_passes
[1]
422 ->shared_quad_state
->quad_to_target_transform
);
424 host_impl_
->DrawLayers(&frame
);
425 host_impl_
->DidDrawAllLayers(frame
);
428 TEST_F(DelegatedRendererLayerImplTestSimple
, RenderPassTransformIsModified
) {
429 LayerTreeHostImpl::FrameData frame
;
430 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
432 // The delegated layer has a surface between it and the root.
433 EXPECT_TRUE(delegated_renderer_layer_
->render_target()->parent());
435 // Each non-DelegatedRendererLayer added one RenderPass. The
436 // DelegatedRendererLayer added two contributing passes.
437 ASSERT_EQ(5u, frame
.render_passes
.size());
439 // The DelegatedRendererLayer is at position 9,9 compared to the root, so all
440 // render pass' transforms to the root should be shifted by this amount.
441 gfx::Transform transform
;
442 transform
.Translate(9.0, 9.0);
444 // The first contributing surface has a translation of 5, 6.
445 gfx::Transform
five_six(1, 0, 0, 1, 5, 6);
447 // The second contributing surface has a translation of 7, 8.
448 gfx::Transform
seven_eight(1, 0, 0, 1, 7, 8);
450 EXPECT_TRANSFORMATION_MATRIX_EQ(
451 transform
* five_six
, frame
.render_passes
[1]->transform_to_root_target
);
452 EXPECT_TRANSFORMATION_MATRIX_EQ(
453 transform
* seven_eight
,
454 frame
.render_passes
[2]->transform_to_root_target
);
456 host_impl_
->DrawLayers(&frame
);
457 host_impl_
->DidDrawAllLayers(frame
);
460 class DelegatedRendererLayerImplTestOwnSurface
461 : public DelegatedRendererLayerImplTestSimple
{
463 DelegatedRendererLayerImplTestOwnSurface()
464 : DelegatedRendererLayerImplTestSimple() {
465 delegated_renderer_layer_
->SetHasRenderSurface(true);
469 TEST_F(DelegatedRendererLayerImplTestOwnSurface
, AddsRenderPasses
) {
470 LayerTreeHostImpl::FrameData frame
;
471 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
473 // Each non-DelegatedRendererLayer added one RenderPass. The
474 // DelegatedRendererLayer added two contributing passes and its owned surface
476 ASSERT_EQ(6u, frame
.render_passes
.size());
478 // The DelegatedRendererLayer should have added its contributing RenderPasses
480 EXPECT_EQ(4, frame
.render_passes
[1]->id
.layer_id
);
481 EXPECT_EQ(1u, frame
.render_passes
[1]->id
.index
);
482 EXPECT_EQ(4, frame
.render_passes
[2]->id
.layer_id
);
483 EXPECT_EQ(2u, frame
.render_passes
[2]->id
.index
);
484 // The DelegatedRendererLayer should have added a RenderPass for its surface
486 EXPECT_EQ(4, frame
.render_passes
[1]->id
.layer_id
);
487 EXPECT_EQ(0u, frame
.render_passes
[3]->id
.index
);
488 // And all other RenderPasses should be non-delegated.
489 EXPECT_NE(4, frame
.render_passes
[0]->id
.layer_id
);
490 EXPECT_EQ(0u, frame
.render_passes
[0]->id
.index
);
491 EXPECT_NE(4, frame
.render_passes
[4]->id
.layer_id
);
492 EXPECT_EQ(0u, frame
.render_passes
[4]->id
.index
);
493 EXPECT_NE(4, frame
.render_passes
[5]->id
.layer_id
);
494 EXPECT_EQ(0u, frame
.render_passes
[5]->id
.index
);
496 // The DelegatedRendererLayer should have added its RenderPasses to the frame
498 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
499 frame
.render_passes
[1]->output_rect
.ToString());
500 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
501 frame
.render_passes
[2]->output_rect
.ToString());
503 host_impl_
->DrawLayers(&frame
);
504 host_impl_
->DidDrawAllLayers(frame
);
507 TEST_F(DelegatedRendererLayerImplTestOwnSurface
,
508 AddsQuadsToContributingRenderPasses
) {
509 LayerTreeHostImpl::FrameData frame
;
510 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
512 // Each non-DelegatedRendererLayer added one RenderPass. The
513 // DelegatedRendererLayer added two contributing passes and its owned surface
515 ASSERT_EQ(6u, frame
.render_passes
.size());
517 // The DelegatedRendererLayer should have added its contributing RenderPasses
519 EXPECT_EQ(4, frame
.render_passes
[1]->id
.layer_id
);
520 EXPECT_EQ(1u, frame
.render_passes
[1]->id
.index
);
521 EXPECT_EQ(4, frame
.render_passes
[2]->id
.layer_id
);
522 EXPECT_EQ(2u, frame
.render_passes
[2]->id
.index
);
524 // The DelegatedRendererLayer should have added copies of its quads to
525 // contributing RenderPasses.
526 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
527 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
528 frame
.render_passes
[1]->quad_list
.front()->rect
.ToString());
530 // Verify it added the right quads.
531 ASSERT_EQ(2u, frame
.render_passes
[2]->quad_list
.size());
533 EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
534 frame
.render_passes
[2]->quad_list
.front()->rect
.ToString());
535 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
536 frame
.render_passes
[2]->quad_list
.ElementAt(1)->rect
.ToString());
537 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
538 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
539 frame
.render_passes
[1]->quad_list
.front()->rect
.ToString());
541 host_impl_
->DrawLayers(&frame
);
542 host_impl_
->DidDrawAllLayers(frame
);
545 TEST_F(DelegatedRendererLayerImplTestOwnSurface
, AddsQuadsToTargetRenderPass
) {
546 LayerTreeHostImpl::FrameData frame
;
547 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
549 // Each non-DelegatedRendererLayer added one RenderPass. The
550 // DelegatedRendererLayer added two contributing passes and its owned surface
552 ASSERT_EQ(6u, frame
.render_passes
.size());
554 // The layer's target is the RenderPass owned by itself.
555 EXPECT_EQ(RenderPassId(4, 0), frame
.render_passes
[3]->id
);
557 // The DelegatedRendererLayer should have added copies of quads in its root
558 // RenderPass to its target RenderPass.
559 // The layer_after also adds one quad.
560 ASSERT_EQ(1u, frame
.render_passes
[3]->quad_list
.size());
562 // Verify it added the right quads.
563 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
564 frame
.render_passes
[3]->quad_list
.front()->rect
.ToString());
566 host_impl_
->DrawLayers(&frame
);
567 host_impl_
->DidDrawAllLayers(frame
);
570 TEST_F(DelegatedRendererLayerImplTestOwnSurface
,
571 QuadsFromRootRenderPassAreNotModifiedForTheTarget
) {
572 LayerTreeHostImpl::FrameData frame
;
573 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
575 // Each non-DelegatedRendererLayer added one RenderPass. The
576 // DelegatedRendererLayer added two contributing passes and its owned surface
578 ASSERT_EQ(6u, frame
.render_passes
.size());
580 // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
581 // RenderPass' quads do not need to be translated at all.
582 EXPECT_TRANSFORMATION_MATRIX_EQ(
583 gfx::Transform(), frame
.render_passes
[3]
585 ->shared_quad_state
->quad_to_target_transform
);
587 // Quads from non-root RenderPasses should not be shifted either.
588 ASSERT_EQ(2u, frame
.render_passes
[2]->quad_list
.size());
590 EXPECT_TRANSFORMATION_MATRIX_EQ(
591 gfx::Transform(), frame
.render_passes
[2]
593 ->shared_quad_state
->quad_to_target_transform
);
594 EXPECT_TRANSFORMATION_MATRIX_EQ(
595 gfx::Transform(), frame
.render_passes
[2]
596 ->quad_list
.ElementAt(1)
597 ->shared_quad_state
->quad_to_target_transform
);
598 ASSERT_EQ(1u, frame
.render_passes
[1]->quad_list
.size());
599 EXPECT_TRANSFORMATION_MATRIX_EQ(
600 gfx::Transform(), frame
.render_passes
[1]
602 ->shared_quad_state
->quad_to_target_transform
);
604 host_impl_
->DrawLayers(&frame
);
605 host_impl_
->DidDrawAllLayers(frame
);
608 class DelegatedRendererLayerImplTestTransform
609 : public DelegatedRendererLayerImplTest
{
611 DelegatedRendererLayerImplTestTransform()
612 : root_delegated_render_pass_is_clipped_(false),
613 delegated_device_scale_factor_(2.f
) {}
616 host_impl_
->SetDeviceScaleFactor(2.f
);
618 scoped_ptr
<LayerImpl
> root_layer
= LayerImpl::Create(
619 host_impl_
->active_tree(), 1);
620 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer
=
621 FakeDelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 2);
623 host_impl_
->SetViewportSize(gfx::Size(200, 200));
624 root_layer
->SetBounds(gfx::Size(100, 100));
625 root_layer
->SetHasRenderSurface(true);
627 delegated_renderer_layer
->SetPosition(gfx::Point(20, 20));
628 delegated_renderer_layer
->SetBounds(gfx::Size(75, 75));
629 delegated_renderer_layer
->SetDrawsContent(true);
630 gfx::Transform transform
;
631 transform
.Scale(2.0, 2.0);
632 transform
.Translate(8.0, 8.0);
633 delegated_renderer_layer
->SetTransform(transform
);
635 RenderPassList delegated_render_passes
;
637 gfx::Size
child_pass_bounds(7, 7);
638 gfx::Rect
child_pass_rect(20, 20, 7, 7);
639 gfx::Transform child_pass_transform
;
640 child_pass_transform
.Scale(0.8f
, 0.8f
);
641 child_pass_transform
.Translate(9.0, 9.0);
642 gfx::Rect
child_pass_clip_rect(21, 21, 3, 3);
643 bool child_pass_clipped
= false;
647 AddRenderPass(&delegated_render_passes
, RenderPassId(10, 7),
648 child_pass_rect
, gfx::Transform());
649 SharedQuadState
* shared_quad_state
=
650 pass
->CreateAndAppendSharedQuadState();
651 shared_quad_state
->SetAll(child_pass_transform
, child_pass_bounds
,
652 child_pass_rect
, child_pass_clip_rect
,
653 child_pass_clipped
, 1.f
,
654 SkXfermode::kSrcOver_Mode
, 0);
656 SolidColorDrawQuad
* color_quad
;
657 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
658 color_quad
->SetNew(shared_quad_state
,
659 gfx::Rect(20, 20, 3, 7),
660 gfx::Rect(20, 20, 3, 7),
664 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
665 color_quad
->SetNew(shared_quad_state
,
666 gfx::Rect(23, 20, 4, 7),
667 gfx::Rect(23, 20, 4, 7),
672 gfx::Size
root_pass_bounds(100, 100);
673 gfx::Rect
root_pass_rect(0, 0, 100, 100);
674 gfx::Transform root_pass_transform
;
675 root_pass_transform
.Scale(1.5, 1.5);
676 root_pass_transform
.Translate(7.0, 7.0);
677 gfx::Rect
root_pass_clip_rect(10, 10, 35, 35);
678 bool root_pass_clipped
= root_delegated_render_pass_is_clipped_
;
681 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 6),
682 root_pass_rect
, gfx::Transform());
683 SharedQuadState
* shared_quad_state
= pass
->CreateAndAppendSharedQuadState();
684 shared_quad_state
->SetAll(root_pass_transform
, root_pass_bounds
,
685 root_pass_rect
, root_pass_clip_rect
,
686 root_pass_clipped
, 1.f
, SkXfermode::kSrcOver_Mode
,
689 RenderPassDrawQuad
* render_pass_quad
=
690 pass
->CreateAndAppendDrawQuad
<RenderPassDrawQuad
>();
691 render_pass_quad
->SetNew(shared_quad_state
,
692 gfx::Rect(5, 5, 7, 7), // quad_rect
693 gfx::Rect(5, 5, 7, 7), // visible_rect
694 RenderPassId(10, 7), // render_pass_id
695 0, // mask_resource_id
696 gfx::Vector2dF(), // mask_uv_scale
697 gfx::Size(), // mask_texture_size
698 FilterOperations(), // filters
699 gfx::Vector2dF(), // filters_scale
700 FilterOperations()); // background_filters
702 SolidColorDrawQuad
* color_quad
;
703 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
704 color_quad
->SetNew(shared_quad_state
,
705 gfx::Rect(0, 0, 10, 10),
706 gfx::Rect(0, 0, 10, 10),
710 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
711 color_quad
->SetNew(shared_quad_state
,
712 gfx::Rect(0, 10, 10, 10),
713 gfx::Rect(0, 10, 10, 10),
717 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
718 color_quad
->SetNew(shared_quad_state
,
719 gfx::Rect(10, 0, 10, 10),
720 gfx::Rect(10, 0, 10, 10),
724 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
725 color_quad
->SetNew(shared_quad_state
,
726 gfx::Rect(10, 10, 10, 10),
727 gfx::Rect(10, 10, 10, 10),
731 delegated_renderer_layer
->SetFrameDataForRenderPasses(
732 delegated_device_scale_factor_
, delegated_render_passes
);
734 root_layer_
= root_layer
.get();
735 delegated_renderer_layer_
= delegated_renderer_layer
.get();
737 root_layer
->AddChild(delegated_renderer_layer
.Pass());
738 host_impl_
->active_tree()->SetRootLayer(root_layer
.Pass());
741 void VerifyRenderPasses(
742 const LayerTreeHostImpl::FrameData
& frame
,
743 size_t num_render_passes
,
744 const SharedQuadState
** root_delegated_shared_quad_state
,
745 const SharedQuadState
** contrib_delegated_shared_quad_state
) {
746 ASSERT_EQ(num_render_passes
, frame
.render_passes
.size());
747 // The contributing render pass in the DelegatedRendererLayer.
748 EXPECT_EQ(2, frame
.render_passes
[0]->id
.layer_id
);
749 EXPECT_EQ(1u, frame
.render_passes
[0]->id
.index
);
750 // The root render pass.
751 EXPECT_EQ(1, frame
.render_passes
.back()->id
.layer_id
);
752 EXPECT_EQ(0u, frame
.render_passes
.back()->id
.index
);
754 const QuadList
& contrib_delegated_quad_list
=
755 frame
.render_passes
[0]->quad_list
;
756 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
758 const QuadList
& root_delegated_quad_list
=
759 frame
.render_passes
[1]->quad_list
;
760 ASSERT_EQ(5u, root_delegated_quad_list
.size());
762 // All quads in a render pass should share the same state.
763 *contrib_delegated_shared_quad_state
=
764 contrib_delegated_quad_list
.front()->shared_quad_state
;
765 EXPECT_EQ(*contrib_delegated_shared_quad_state
,
766 contrib_delegated_quad_list
.ElementAt(1)->shared_quad_state
);
768 *root_delegated_shared_quad_state
=
769 root_delegated_quad_list
.front()->shared_quad_state
;
770 EXPECT_EQ(*root_delegated_shared_quad_state
,
771 root_delegated_quad_list
.ElementAt(1)->shared_quad_state
);
772 EXPECT_EQ(*root_delegated_shared_quad_state
,
773 root_delegated_quad_list
.ElementAt(2)->shared_quad_state
);
774 EXPECT_EQ(*root_delegated_shared_quad_state
,
775 root_delegated_quad_list
.ElementAt(3)->shared_quad_state
);
776 EXPECT_EQ(*root_delegated_shared_quad_state
,
777 root_delegated_quad_list
.ElementAt(4)->shared_quad_state
);
779 EXPECT_NE(*contrib_delegated_shared_quad_state
,
780 *root_delegated_shared_quad_state
);
784 LayerImpl
* root_layer_
;
785 DelegatedRendererLayerImpl
* delegated_renderer_layer_
;
786 bool root_delegated_render_pass_is_clipped_
;
787 float delegated_device_scale_factor_
;
790 TEST_F(DelegatedRendererLayerImplTestTransform
, QuadsUnclipped_NoSurface
) {
791 root_delegated_render_pass_is_clipped_
= false;
794 LayerTreeHostImpl::FrameData frame
;
795 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
797 const SharedQuadState
* root_delegated_shared_quad_state
= nullptr;
798 const SharedQuadState
* contrib_delegated_shared_quad_state
= nullptr;
802 &root_delegated_shared_quad_state
,
803 &contrib_delegated_shared_quad_state
);
805 // When the quads don't have a clip of their own, the clip rect is set to
806 // the drawable_content_rect of the delegated renderer layer.
807 EXPECT_EQ(delegated_renderer_layer_
->drawable_content_rect().ToString(),
808 root_delegated_shared_quad_state
->clip_rect
.ToString());
810 // Even though the quads in the root pass have no clip of their own, they
811 // inherit the clip rect from the delegated renderer layer if it does not
813 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
815 gfx::Transform expected
;
816 // Device scale factor.
817 expected
.Scale(2.0, 2.0);
818 // This is the transform from the layer's space to its target.
819 expected
.Translate(20, 20);
820 expected
.Scale(2.0, 2.0);
821 expected
.Translate(8.0, 8.0);
822 // This is the transform within the source frame.
823 // Inverse device scale factor to go from physical space to layer space.
824 expected
.Scale(0.5, 0.5);
825 expected
.Scale(1.5, 1.5);
826 expected
.Translate(7.0, 7.0);
827 EXPECT_TRANSFORMATION_MATRIX_EQ(
828 expected
, root_delegated_shared_quad_state
->quad_to_target_transform
);
830 // The contributing render pass should not be transformed from its input.
831 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
832 contrib_delegated_shared_quad_state
->clip_rect
.ToString());
833 EXPECT_FALSE(contrib_delegated_shared_quad_state
->is_clipped
);
834 expected
.MakeIdentity();
835 expected
.Scale(0.8f
, 0.8f
);
836 expected
.Translate(9.0, 9.0);
837 EXPECT_TRANSFORMATION_MATRIX_EQ(
838 expected
, contrib_delegated_shared_quad_state
->quad_to_target_transform
);
840 host_impl_
->DrawLayers(&frame
);
841 host_impl_
->DidDrawAllLayers(frame
);
844 TEST_F(DelegatedRendererLayerImplTestTransform
, QuadsClipped_NoSurface
) {
845 root_delegated_render_pass_is_clipped_
= true;
848 LayerTreeHostImpl::FrameData frame
;
849 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
851 const SharedQuadState
* root_delegated_shared_quad_state
= nullptr;
852 const SharedQuadState
* contrib_delegated_shared_quad_state
= nullptr;
856 &root_delegated_shared_quad_state
,
857 &contrib_delegated_shared_quad_state
);
859 // Since the quads have a clip_rect it should be modified by delegated
860 // renderer layer's draw_transform.
861 // The position of the resulting clip_rect is:
862 // (clip rect position (10) * inverse dsf (1/2) + translate (8)) *
863 // layer scale (2) + layer position (20) = 46
864 // The device scale is 2, so everything gets doubled, giving 92.
866 // The size is 35x35 scaled by the device scale.
867 EXPECT_EQ(gfx::Rect(92, 92, 70, 70).ToString(),
868 root_delegated_shared_quad_state
->clip_rect
.ToString());
870 // The quads had a clip and it should be preserved.
871 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
873 gfx::Transform expected
;
874 // Device scale factor.
875 expected
.Scale(2.0, 2.0);
876 // This is the transform from the layer's space to its target.
877 expected
.Translate(20, 20);
878 expected
.Scale(2.0, 2.0);
879 expected
.Translate(8.0, 8.0);
880 // This is the transform within the source frame.
881 // Inverse device scale factor to go from physical space to layer space.
882 expected
.Scale(0.5, 0.5);
883 expected
.Scale(1.5, 1.5);
884 expected
.Translate(7.0, 7.0);
885 EXPECT_TRANSFORMATION_MATRIX_EQ(
886 expected
, root_delegated_shared_quad_state
->quad_to_target_transform
);
888 // The contributing render pass should not be transformed from its input.
889 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
890 contrib_delegated_shared_quad_state
->clip_rect
.ToString());
891 EXPECT_FALSE(contrib_delegated_shared_quad_state
->is_clipped
);
892 expected
.MakeIdentity();
893 expected
.Scale(0.8f
, 0.8f
);
894 expected
.Translate(9.0, 9.0);
895 EXPECT_TRANSFORMATION_MATRIX_EQ(
896 expected
, contrib_delegated_shared_quad_state
->quad_to_target_transform
);
898 host_impl_
->DrawLayers(&frame
);
899 host_impl_
->DidDrawAllLayers(frame
);
902 TEST_F(DelegatedRendererLayerImplTestTransform
, QuadsUnclipped_Surface
) {
903 root_delegated_render_pass_is_clipped_
= false;
906 delegated_renderer_layer_
->SetHasRenderSurface(true);
908 LayerTreeHostImpl::FrameData frame
;
909 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
911 const SharedQuadState
* root_delegated_shared_quad_state
= nullptr;
912 const SharedQuadState
* contrib_delegated_shared_quad_state
= nullptr;
916 &root_delegated_shared_quad_state
,
917 &contrib_delegated_shared_quad_state
);
919 // When the layer owns a surface, then its translation is not part of its
920 // draw transform, but its scale is.
921 EXPECT_EQ(gfx::Rect(20, 20, 70, 70).ToString(),
922 root_delegated_shared_quad_state
->clip_rect
.ToString());
924 // Since the layer owns a surface it doesn't need to clip its quads, so
925 // unclipped quads remain unclipped.
926 EXPECT_FALSE(root_delegated_shared_quad_state
->is_clipped
);
928 gfx::Transform expected
;
929 // This is the transform within the source frame scaled by the delegated
930 // render layer transform.
931 expected
.Scale(3.0, 3.0);
932 expected
.Translate(7.0, 7.0);
933 EXPECT_TRANSFORMATION_MATRIX_EQ(
934 expected
, root_delegated_shared_quad_state
->quad_to_target_transform
);
936 // The contributing render pass should not be transformed from its input.
937 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
938 contrib_delegated_shared_quad_state
->clip_rect
.ToString());
939 EXPECT_FALSE(contrib_delegated_shared_quad_state
->is_clipped
);
940 expected
.MakeIdentity();
941 expected
.Scale(0.8f
, 0.8f
);
942 expected
.Translate(9.0, 9.0);
943 EXPECT_TRANSFORMATION_MATRIX_EQ(
944 expected
, contrib_delegated_shared_quad_state
->quad_to_target_transform
);
946 host_impl_
->DrawLayers(&frame
);
947 host_impl_
->DidDrawAllLayers(frame
);
950 TEST_F(DelegatedRendererLayerImplTestTransform
, QuadsClipped_Surface
) {
951 root_delegated_render_pass_is_clipped_
= true;
954 delegated_renderer_layer_
->SetHasRenderSurface(true);
956 LayerTreeHostImpl::FrameData frame
;
957 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
959 const SharedQuadState
* root_delegated_shared_quad_state
= nullptr;
960 const SharedQuadState
* contrib_delegated_shared_quad_state
= nullptr;
964 &root_delegated_shared_quad_state
,
965 &contrib_delegated_shared_quad_state
);
967 // When the layer owns a surface, then its translation is not part of its
968 // draw transform, but its scale is.
969 EXPECT_EQ(gfx::Rect(20, 20, 70, 70).ToString(),
970 root_delegated_shared_quad_state
->clip_rect
.ToString());
972 // The quads had a clip and it should be preserved.
973 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
975 gfx::Transform expected
;
976 // This is the transform within the source frame scaled by the delegated
977 // render layer transform.
978 expected
.Scale(3.0, 3.0);
979 expected
.Translate(7.0, 7.0);
980 EXPECT_TRANSFORMATION_MATRIX_EQ(
981 expected
, root_delegated_shared_quad_state
->quad_to_target_transform
);
983 // The contributing render pass should not be transformed from its input.
984 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
985 contrib_delegated_shared_quad_state
->clip_rect
.ToString());
986 EXPECT_FALSE(contrib_delegated_shared_quad_state
->is_clipped
);
987 expected
.MakeIdentity();
988 expected
.Scale(0.8f
, 0.8f
);
989 expected
.Translate(9.0, 9.0);
990 EXPECT_TRANSFORMATION_MATRIX_EQ(
991 expected
, contrib_delegated_shared_quad_state
->quad_to_target_transform
);
993 host_impl_
->DrawLayers(&frame
);
994 host_impl_
->DidDrawAllLayers(frame
);
997 TEST_F(DelegatedRendererLayerImplTestTransform
, MismatchedDeviceScaleFactor
) {
998 root_delegated_render_pass_is_clipped_
= true;
999 delegated_device_scale_factor_
= 1.3f
;
1003 LayerTreeHostImpl::FrameData frame
;
1004 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1006 const SharedQuadState
* root_delegated_shared_quad_state
= nullptr;
1007 const SharedQuadState
* contrib_delegated_shared_quad_state
= nullptr;
1008 VerifyRenderPasses(frame
,
1010 &root_delegated_shared_quad_state
,
1011 &contrib_delegated_shared_quad_state
);
1013 // The parent tree's device scale factor is 2.0, but the child has submitted a
1014 // frame with a device scale factor of 1.3. Absent any better option, the
1015 // only thing we can do is scale from 1.3 -> 2.0.
1017 gfx::Transform expected
;
1018 // Device scale factor (from parent).
1019 expected
.Scale(2.0, 2.0);
1020 // This is the transform from the layer's space to its target.
1021 expected
.Translate(20, 20);
1022 expected
.Scale(2.0, 2.0);
1023 expected
.Translate(8.0, 8.0);
1024 // This is the transform within the source frame.
1025 // Inverse device scale factor (from child).
1026 expected
.Scale(1.0f
/ 1.3f
, 1.0f
/ 1.3f
);
1027 expected
.Scale(1.5, 1.5);
1028 expected
.Translate(7.0, 7.0);
1029 EXPECT_TRANSFORMATION_MATRIX_EQ(
1030 expected
, root_delegated_shared_quad_state
->quad_to_target_transform
);
1032 host_impl_
->DrawLayers(&frame
);
1033 host_impl_
->DidDrawAllLayers(frame
);
1036 class DelegatedRendererLayerImplTestClip
1037 : public DelegatedRendererLayerImplTest
{
1040 scoped_ptr
<LayerImpl
> root_layer
=
1041 LayerImpl::Create(host_impl_
->active_tree(), 1);
1042 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer
=
1043 FakeDelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 2);
1044 scoped_ptr
<LayerImpl
> clip_layer
=
1045 LayerImpl::Create(host_impl_
->active_tree(), 3);
1046 scoped_ptr
<LayerImpl
> origin_layer
=
1047 LayerImpl::Create(host_impl_
->active_tree(), 4);
1049 host_impl_
->SetViewportSize(gfx::Size(100, 100));
1050 root_layer
->SetBounds(gfx::Size(100, 100));
1051 root_layer
->SetHasRenderSurface(true);
1053 delegated_renderer_layer
->SetPosition(gfx::Point(20, 20));
1054 delegated_renderer_layer
->SetBounds(gfx::Size(50, 50));
1055 delegated_renderer_layer
->SetDrawsContent(true);
1057 RenderPassList delegated_render_passes
;
1059 gfx::Size
child_pass_bounds(7, 7);
1060 gfx::Rect
child_pass_rect(20, 20, 7, 7);
1061 gfx::Transform child_pass_transform
;
1062 gfx::Rect
child_pass_clip_rect(21, 21, 3, 3);
1063 bool child_pass_clipped
= false;
1067 AddRenderPass(&delegated_render_passes
, RenderPassId(10, 7),
1068 child_pass_rect
, gfx::Transform());
1069 SharedQuadState
* shared_quad_state
=
1070 pass
->CreateAndAppendSharedQuadState();
1071 shared_quad_state
->SetAll(child_pass_transform
, child_pass_bounds
,
1072 child_pass_rect
, child_pass_clip_rect
,
1073 child_pass_clipped
, 1.f
,
1074 SkXfermode::kSrcOver_Mode
, 0);
1076 SolidColorDrawQuad
* color_quad
;
1077 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1078 color_quad
->SetNew(shared_quad_state
,
1079 gfx::Rect(20, 20, 3, 7),
1080 gfx::Rect(20, 20, 3, 7),
1084 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1085 color_quad
->SetNew(shared_quad_state
,
1086 gfx::Rect(23, 20, 4, 7),
1087 gfx::Rect(23, 20, 4, 7),
1092 gfx::Size
root_pass_bounds(50, 50);
1093 gfx::Rect
root_pass_rect(0, 0, 50, 50);
1094 gfx::Transform root_pass_transform
;
1095 gfx::Rect
root_pass_clip_rect(5, 5, 40, 40);
1096 bool root_pass_clipped
= root_delegated_render_pass_is_clipped_
;
1099 AddRenderPass(&delegated_render_passes
, RenderPassId(9, 6),
1100 root_pass_rect
, gfx::Transform());
1101 SharedQuadState
* shared_quad_state
= pass
->CreateAndAppendSharedQuadState();
1102 shared_quad_state
->SetAll(root_pass_transform
, root_pass_bounds
,
1103 root_pass_rect
, root_pass_clip_rect
,
1104 root_pass_clipped
, 1.f
, SkXfermode::kSrcOver_Mode
,
1107 RenderPassDrawQuad
* render_pass_quad
=
1108 pass
->CreateAndAppendDrawQuad
<RenderPassDrawQuad
>();
1109 render_pass_quad
->SetNew(shared_quad_state
,
1110 gfx::Rect(5, 5, 7, 7), // quad_rect
1111 gfx::Rect(5, 5, 7, 7), // visible_quad_rect
1112 RenderPassId(10, 7), // render_pass_id
1113 0, // mask_resource_id
1114 gfx::Vector2dF(), // mask_uv_scale
1115 gfx::Size(), // mask_texture_size,
1116 FilterOperations(), // filters
1117 gfx::Vector2dF(), // filters_scale
1118 FilterOperations()); // background_filters
1120 SolidColorDrawQuad
* color_quad
;
1121 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1122 color_quad
->SetNew(shared_quad_state
,
1123 gfx::Rect(0, 0, 10, 10),
1124 gfx::Rect(0, 0, 10, 10),
1128 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1129 color_quad
->SetNew(shared_quad_state
,
1130 gfx::Rect(0, 10, 10, 10),
1131 gfx::Rect(0, 10, 10, 10),
1135 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1136 color_quad
->SetNew(shared_quad_state
,
1137 gfx::Rect(10, 0, 10, 10),
1138 gfx::Rect(10, 0, 10, 10),
1142 color_quad
= pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
1143 color_quad
->SetNew(shared_quad_state
,
1144 gfx::Rect(10, 10, 10, 10),
1145 gfx::Rect(10, 10, 10, 10),
1149 delegated_renderer_layer
->SetFrameDataForRenderPasses(
1150 1.f
, delegated_render_passes
);
1152 root_layer_
= root_layer
.get();
1153 delegated_renderer_layer_
= delegated_renderer_layer
.get();
1155 if (clip_delegated_renderer_layer_
) {
1156 gfx::Rect
clip_rect(21, 27, 23, 21);
1158 clip_layer
->SetPosition(clip_rect
.origin());
1159 clip_layer
->SetBounds(clip_rect
.size());
1160 clip_layer
->SetMasksToBounds(true);
1162 origin_layer
->SetPosition(
1163 gfx::PointAtOffsetFromOrigin(-clip_rect
.OffsetFromOrigin()));
1165 origin_layer
->AddChild(delegated_renderer_layer
.Pass());
1166 clip_layer
->AddChild(origin_layer
.Pass());
1167 root_layer
->AddChild(clip_layer
.Pass());
1169 root_layer
->AddChild(delegated_renderer_layer
.Pass());
1172 host_impl_
->active_tree()->SetRootLayer(root_layer
.Pass());
1176 LayerImpl
* root_layer_
;
1177 DelegatedRendererLayerImpl
* delegated_renderer_layer_
;
1178 bool root_delegated_render_pass_is_clipped_
;
1179 bool clip_delegated_renderer_layer_
;
1182 TEST_F(DelegatedRendererLayerImplTestClip
,
1183 QuadsUnclipped_LayerUnclipped_NoSurface
) {
1184 root_delegated_render_pass_is_clipped_
= false;
1185 clip_delegated_renderer_layer_
= false;
1188 LayerTreeHostImpl::FrameData frame
;
1189 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1191 ASSERT_EQ(2u, frame
.render_passes
.size());
1192 const QuadList
& contrib_delegated_quad_list
=
1193 frame
.render_passes
[0]->quad_list
;
1194 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1195 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1196 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1197 const SharedQuadState
* root_delegated_shared_quad_state
=
1198 root_delegated_quad_list
.front()->shared_quad_state
;
1200 // When the quads don't have a clip of their own, the clip rect is set to
1201 // the drawable_content_rect of the delegated renderer layer.
1202 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
1203 root_delegated_shared_quad_state
->clip_rect
.ToString());
1204 // Quads are clipped to the delegated renderer layer.
1205 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1207 host_impl_
->DrawLayers(&frame
);
1208 host_impl_
->DidDrawAllLayers(frame
);
1211 TEST_F(DelegatedRendererLayerImplTestClip
,
1212 QuadsClipped_LayerUnclipped_NoSurface
) {
1213 root_delegated_render_pass_is_clipped_
= true;
1214 clip_delegated_renderer_layer_
= false;
1217 LayerTreeHostImpl::FrameData frame
;
1218 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1220 ASSERT_EQ(2u, frame
.render_passes
.size());
1221 const QuadList
& contrib_delegated_quad_list
=
1222 frame
.render_passes
[0]->quad_list
;
1223 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1224 const QuadList
& root_delegated_quad_list
=
1225 frame
.render_passes
[1]->quad_list
;
1226 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1227 const SharedQuadState
* root_delegated_shared_quad_state
=
1228 root_delegated_quad_list
.front()->shared_quad_state
;
1230 // When the quads have a clip of their own, it is used.
1231 EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
1232 root_delegated_shared_quad_state
->clip_rect
.ToString());
1233 // Quads came with a clip rect.
1234 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1236 host_impl_
->DrawLayers(&frame
);
1237 host_impl_
->DidDrawAllLayers(frame
);
1240 TEST_F(DelegatedRendererLayerImplTestClip
,
1241 QuadsUnclipped_LayerClipped_NoSurface
) {
1242 root_delegated_render_pass_is_clipped_
= false;
1243 clip_delegated_renderer_layer_
= true;
1246 LayerTreeHostImpl::FrameData frame
;
1247 host_impl_
->active_tree()->BuildPropertyTreesForTesting();
1248 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1250 ASSERT_EQ(2u, frame
.render_passes
.size());
1251 const QuadList
& contrib_delegated_quad_list
=
1252 frame
.render_passes
[0]->quad_list
;
1253 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1254 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1255 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1256 const SharedQuadState
* root_delegated_shared_quad_state
=
1257 root_delegated_quad_list
.front()->shared_quad_state
;
1259 // When the quads don't have a clip of their own, the clip rect is set to
1260 // the drawable_content_rect of the delegated renderer layer. When the layer
1261 // is clipped, that should be seen in the quads' clip_rect.
1262 EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
1263 root_delegated_shared_quad_state
->clip_rect
.ToString());
1264 // Quads are clipped to the delegated renderer layer.
1265 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1267 host_impl_
->DrawLayers(&frame
);
1268 host_impl_
->DidDrawAllLayers(frame
);
1271 TEST_F(DelegatedRendererLayerImplTestClip
,
1272 QuadsClipped_LayerClipped_NoSurface
) {
1273 root_delegated_render_pass_is_clipped_
= true;
1274 clip_delegated_renderer_layer_
= true;
1277 LayerTreeHostImpl::FrameData frame
;
1278 host_impl_
->active_tree()->BuildPropertyTreesForTesting();
1279 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1281 ASSERT_EQ(2u, frame
.render_passes
.size());
1282 const QuadList
& contrib_delegated_quad_list
=
1283 frame
.render_passes
[0]->quad_list
;
1284 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1285 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1286 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1287 const SharedQuadState
* root_delegated_shared_quad_state
=
1288 root_delegated_quad_list
.front()->shared_quad_state
;
1290 // When the quads have a clip of their own, it is used, but it is
1291 // combined with the clip rect of the delegated renderer layer.
1292 EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(),
1293 root_delegated_shared_quad_state
->clip_rect
.ToString());
1294 // Quads came with a clip rect.
1295 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1297 host_impl_
->DrawLayers(&frame
);
1298 host_impl_
->DidDrawAllLayers(frame
);
1301 TEST_F(DelegatedRendererLayerImplTestClip
,
1302 QuadsUnclipped_LayerUnclipped_Surface
) {
1303 root_delegated_render_pass_is_clipped_
= false;
1304 clip_delegated_renderer_layer_
= false;
1307 delegated_renderer_layer_
->SetHasRenderSurface(true);
1309 LayerTreeHostImpl::FrameData frame
;
1310 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1312 ASSERT_EQ(3u, frame
.render_passes
.size());
1313 const QuadList
& contrib_delegated_quad_list
=
1314 frame
.render_passes
[0]->quad_list
;
1315 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1316 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1317 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1318 const SharedQuadState
* root_delegated_shared_quad_state
=
1319 root_delegated_quad_list
.front()->shared_quad_state
;
1321 // When the layer owns a surface, the quads don't need to be clipped
1322 // further than they already specify. If they aren't clipped, then their
1323 // clip rect is ignored, and they are not set as clipped.
1324 EXPECT_FALSE(root_delegated_shared_quad_state
->is_clipped
);
1326 host_impl_
->DrawLayers(&frame
);
1327 host_impl_
->DidDrawAllLayers(frame
);
1330 TEST_F(DelegatedRendererLayerImplTestClip
,
1331 QuadsClipped_LayerUnclipped_Surface
) {
1332 root_delegated_render_pass_is_clipped_
= true;
1333 clip_delegated_renderer_layer_
= false;
1336 delegated_renderer_layer_
->SetHasRenderSurface(true);
1338 LayerTreeHostImpl::FrameData frame
;
1339 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1341 ASSERT_EQ(3u, frame
.render_passes
.size());
1342 const QuadList
& contrib_delegated_quad_list
=
1343 frame
.render_passes
[0]->quad_list
;
1344 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1345 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1346 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1347 const SharedQuadState
* root_delegated_shared_quad_state
=
1348 root_delegated_quad_list
.front()->shared_quad_state
;
1350 // When the quads have a clip of their own, it is used.
1351 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1352 root_delegated_shared_quad_state
->clip_rect
.ToString());
1353 // Quads came with a clip rect.
1354 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1356 host_impl_
->DrawLayers(&frame
);
1357 host_impl_
->DidDrawAllLayers(frame
);
1360 TEST_F(DelegatedRendererLayerImplTestClip
,
1361 QuadsUnclipped_LayerClipped_Surface
) {
1362 root_delegated_render_pass_is_clipped_
= false;
1363 clip_delegated_renderer_layer_
= true;
1366 delegated_renderer_layer_
->SetHasRenderSurface(true);
1368 LayerTreeHostImpl::FrameData frame
;
1369 host_impl_
->active_tree()->BuildPropertyTreesForTesting();
1370 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1372 ASSERT_EQ(3u, frame
.render_passes
.size());
1373 const QuadList
& contrib_delegated_quad_list
=
1374 frame
.render_passes
[0]->quad_list
;
1375 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1376 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1377 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1378 const SharedQuadState
* root_delegated_shared_quad_state
=
1379 root_delegated_quad_list
.front()->shared_quad_state
;
1381 // When the layer owns a surface, the quads don't need to be clipped
1382 // further than they already specify. If they aren't clipped, then their
1383 // clip rect is ignored, and they are not set as clipped.
1384 EXPECT_FALSE(root_delegated_shared_quad_state
->is_clipped
);
1386 host_impl_
->DrawLayers(&frame
);
1387 host_impl_
->DidDrawAllLayers(frame
);
1390 TEST_F(DelegatedRendererLayerImplTestClip
, QuadsClipped_LayerClipped_Surface
) {
1391 root_delegated_render_pass_is_clipped_
= true;
1392 clip_delegated_renderer_layer_
= true;
1395 delegated_renderer_layer_
->SetHasRenderSurface(true);
1397 LayerTreeHostImpl::FrameData frame
;
1398 host_impl_
->active_tree()->BuildPropertyTreesForTesting();
1399 EXPECT_EQ(DRAW_SUCCESS
, host_impl_
->PrepareToDraw(&frame
));
1401 ASSERT_EQ(3u, frame
.render_passes
.size());
1402 const QuadList
& contrib_delegated_quad_list
=
1403 frame
.render_passes
[0]->quad_list
;
1404 ASSERT_EQ(2u, contrib_delegated_quad_list
.size());
1405 const QuadList
& root_delegated_quad_list
= frame
.render_passes
[1]->quad_list
;
1406 ASSERT_EQ(5u, root_delegated_quad_list
.size());
1407 const SharedQuadState
* root_delegated_shared_quad_state
=
1408 root_delegated_quad_list
.front()->shared_quad_state
;
1410 // When the quads have a clip of their own, it is used, but it is
1411 // combined with the clip rect of the delegated renderer layer. If the
1412 // layer owns a surface, then it does not have a clip rect of its own.
1413 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1414 root_delegated_shared_quad_state
->clip_rect
.ToString());
1415 // Quads came with a clip rect.
1416 EXPECT_TRUE(root_delegated_shared_quad_state
->is_clipped
);
1418 host_impl_
->DrawLayers(&frame
);
1419 host_impl_
->DidDrawAllLayers(frame
);
1422 TEST_F(DelegatedRendererLayerImplTest
, Occlusion
) {
1423 gfx::Size
layer_size(1000, 1000);
1424 gfx::Size
viewport_size(1000, 1000);
1425 gfx::Rect
quad_screen_rect(211, 300, 400, 500);
1427 gfx::Transform transform
;
1428 transform
.Translate(211.0, 300.0);
1430 LayerTestCommon::LayerImplTest impl
;
1432 FakeDelegatedRendererLayerImpl
* delegated_renderer_layer_impl
=
1433 impl
.AddChildToRoot
<FakeDelegatedRendererLayerImpl
>();
1434 delegated_renderer_layer_impl
->SetBounds(layer_size
);
1435 delegated_renderer_layer_impl
->SetDrawsContent(true);
1437 // Contributing render pass is offset by a transform and holds a quad that
1438 // covers it entirely.
1439 RenderPassList delegated_render_passes
;
1440 // pass2 is just the size of the quad. It contributes to |pass1| with a
1441 // translation of (211,300).
1442 RenderPassId pass2_id
=
1443 delegated_renderer_layer_impl
->FirstContributingRenderPassId();
1445 AddRenderPass(&delegated_render_passes
, pass2_id
,
1446 gfx::Rect(quad_screen_rect
.size()), transform
);
1447 AddQuad(pass2
, gfx::Rect(quad_screen_rect
.size()), SK_ColorRED
);
1448 // |pass1| covers the whole layer.
1449 RenderPassId pass1_id
= RenderPassId(impl
.root_layer()->id(), 0);
1450 RenderPass
* pass1
= AddRenderPass(&delegated_render_passes
, pass1_id
,
1451 gfx::Rect(layer_size
), gfx::Transform());
1452 AddRenderPassQuad(pass1
,
1457 SkXfermode::kSrcOver_Mode
);
1458 delegated_renderer_layer_impl
->SetFrameDataForRenderPasses(
1459 1.f
, delegated_render_passes
);
1461 impl
.CalcDrawProps(viewport_size
);
1464 SCOPED_TRACE("No occlusion");
1468 SCOPED_TRACE("Root render pass");
1469 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass1
,
1471 LayerTestCommon::VerifyQuadsExactlyCoverRect(pass1
->quad_list
,
1473 ASSERT_EQ(1u, pass1
->quad_list
.size());
1474 EXPECT_EQ(DrawQuad::RENDER_PASS
, pass1
->quad_list
.front()->material
);
1477 SCOPED_TRACE("Contributing render pass");
1478 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass2
,
1480 LayerTestCommon::VerifyQuadsExactlyCoverRect(
1481 pass2
->quad_list
, gfx::Rect(quad_screen_rect
.size()));
1482 ASSERT_EQ(1u, pass2
->quad_list
.size());
1483 EXPECT_EQ(DrawQuad::SOLID_COLOR
, pass2
->quad_list
.front()->material
);
1488 SCOPED_TRACE("Full occlusion");
1490 gfx::Rect
occluded(delegated_renderer_layer_impl
->visible_layer_rect());
1492 SCOPED_TRACE("Root render pass");
1493 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass1
,
1495 LayerTestCommon::VerifyQuadsExactlyCoverRect(pass1
->quad_list
,
1497 EXPECT_EQ(pass1
->quad_list
.size(), 0u);
1500 gfx::Rect
occluded(delegated_renderer_layer_impl
->visible_layer_rect());
1502 SCOPED_TRACE("Contributing render pass");
1503 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass2
,
1505 LayerTestCommon::VerifyQuadsExactlyCoverRect(pass2
->quad_list
,
1507 EXPECT_EQ(pass2
->quad_list
.size(), 0u);
1512 SCOPED_TRACE("Partial occlusion");
1514 gfx::Rect
occlusion_in_root_target(0, 0, 500, 1000);
1516 SCOPED_TRACE("Root render pass");
1517 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass1
,
1518 occlusion_in_root_target
);
1519 size_t partially_occluded_count
= 0;
1520 LayerTestCommon::VerifyQuadsAreOccluded(pass1
->quad_list
,
1521 occlusion_in_root_target
,
1522 &partially_occluded_count
);
1523 // The layer outputs one quad, which is partially occluded.
1524 EXPECT_EQ(1u, pass1
->quad_list
.size());
1525 EXPECT_EQ(1u, partially_occluded_count
);
1528 gfx::Rect
occlusion_in_root_target(0, 0, 500, 1000);
1529 // Move the occlusion to where it is in the contributing surface.
1530 gfx::Rect occlusion_in_target_of_delegated_quad
=
1531 occlusion_in_root_target
- quad_screen_rect
.OffsetFromOrigin();
1533 SCOPED_TRACE("Contributing render pass");
1534 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass2
,
1535 occlusion_in_root_target
);
1536 size_t partially_occluded_count
= 0;
1537 LayerTestCommon::VerifyQuadsAreOccluded(
1538 pass2
->quad_list
, occlusion_in_target_of_delegated_quad
,
1539 &partially_occluded_count
);
1540 // The layer outputs one quad, which is partially occluded.
1541 EXPECT_EQ(1u, pass2
->quad_list
.size());
1542 EXPECT_EQ(1u, partially_occluded_count
);
1543 // The quad in the contributing surface is at (211,300) in the root.
1544 // The occlusion extends to 500 in the x-axis, pushing the left of the
1545 // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
1546 EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
1547 pass2
->quad_list
.front()->visible_rect
.ToString());
1550 gfx::Rect
occlusion_in_root_target(0, 0, 500, 1000);
1551 // Move the occlusion to where it is in the contributing surface.
1552 gfx::Rect occlusion_in_target_of_delegated_quad
=
1553 occlusion_in_root_target
- quad_screen_rect
.OffsetFromOrigin();
1555 SCOPED_TRACE("Contributing render pass with transformed root");
1557 gfx::Transform layer_transform
;
1558 layer_transform
.Translate(11.0, 0.0);
1559 delegated_renderer_layer_impl
->SetTransform(layer_transform
);
1560 delegated_renderer_layer_impl
->layer_tree_impl()
1562 ->needs_rebuild
= true;
1564 occlusion_in_target_of_delegated_quad
+= gfx::Vector2d(11, 0);
1566 impl
.CalcDrawProps(viewport_size
);
1568 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass2
,
1569 occlusion_in_root_target
);
1570 size_t partially_occluded_count
= 0;
1571 LayerTestCommon::VerifyQuadsAreOccluded(
1572 pass2
->quad_list
, occlusion_in_target_of_delegated_quad
,
1573 &partially_occluded_count
);
1574 // The layer outputs one quad, which is partially occluded.
1575 EXPECT_EQ(1u, pass2
->quad_list
.size());
1576 EXPECT_EQ(1u, partially_occluded_count
);
1577 // The quad in the contributing surface is at (222,300) in the transformed
1578 // root. The occlusion extends to 500 in the x-axis, pushing the left of
1579 // the visible part of the quad to 500 - 222 = 300 - 22 inside the quad.
1580 EXPECT_EQ(gfx::Rect(300 - 22, 0, 100 + 22, 500).ToString(),
1581 pass2
->quad_list
.front()->visible_rect
.ToString());
1586 TEST_F(DelegatedRendererLayerImplTest
, DeviceScaleFactorOcclusion
) {
1587 gfx::Size
layer_size(1000, 1000);
1588 gfx::Size
viewport_size(1000, 1000);
1589 gfx::Rect
quad_screen_rect(211, 300, 400, 500);
1591 gfx::Transform transform
;
1592 transform
.Translate(211.f
, 300.f
);
1594 LayerTestCommon::LayerImplTest impl
;
1596 FakeDelegatedRendererLayerImpl
* delegated_renderer_layer_impl
=
1597 impl
.AddChildToRoot
<FakeDelegatedRendererLayerImpl
>();
1598 delegated_renderer_layer_impl
->SetBounds(layer_size
);
1599 delegated_renderer_layer_impl
->SetDrawsContent(true);
1601 // Contributing render pass is offset by a transform and holds a quad that
1602 // covers it entirely.
1603 RenderPassList delegated_render_passes
;
1604 // pass2 is just the size of the quad. It contributes to |pass1| with a
1605 // translation of (211,300).
1606 RenderPassId pass2_id
=
1607 delegated_renderer_layer_impl
->FirstContributingRenderPassId();
1609 AddRenderPass(&delegated_render_passes
, pass2_id
,
1610 gfx::Rect(quad_screen_rect
.size()), transform
);
1611 AddQuad(pass2
, gfx::Rect(quad_screen_rect
.size()), SK_ColorRED
);
1612 // |pass1| covers the whole layer.
1613 RenderPassId pass1_id
= RenderPassId(impl
.root_layer()->id(), 0);
1614 RenderPass
* pass1
= AddRenderPass(&delegated_render_passes
, pass1_id
,
1615 gfx::Rect(layer_size
), gfx::Transform());
1616 AddRenderPassQuad(pass1
, pass2
, 0, FilterOperations(), transform
,
1617 SkXfermode::kSrcOver_Mode
);
1618 delegated_renderer_layer_impl
->SetFrameDataForRenderPasses(
1619 1.2f
, delegated_render_passes
);
1622 SCOPED_TRACE("Partial occlusion");
1624 gfx::Rect
occlusion_in_root_target(0, 0, 500, 1000);
1625 // Move the occlusion to where it is in the contributing surface.
1626 gfx::Rect occlusion_in_target_of_delegated_quad
=
1627 occlusion_in_root_target
- quad_screen_rect
.OffsetFromOrigin();
1629 SCOPED_TRACE("Contributing render pass");
1630 impl
.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl
, pass2
,
1631 occlusion_in_root_target
);
1632 size_t partially_occluded_count
= 0;
1633 LayerTestCommon::VerifyQuadsAreOccluded(
1634 pass2
->quad_list
, occlusion_in_target_of_delegated_quad
,
1635 &partially_occluded_count
);
1636 // The layer outputs one quad, which is partially occluded.
1637 EXPECT_EQ(1u, pass2
->quad_list
.size());
1638 EXPECT_EQ(1u, partially_occluded_count
);
1639 // The quad in the contributing surface is at (211,300) in the root.
1640 // The occlusion extends to 500 * 1.2 (dsf) = 600 in the x-axis, pushing
1641 // the left of the visible part of the quad to 600 - 211 = 400 - 11 inside
1643 EXPECT_EQ(gfx::Rect(400 - 11, 0, 11, 500).ToString(),
1644 pass2
->quad_list
.front()->visible_rect
.ToString());
1649 TEST_F(DelegatedRendererLayerImplTest
, PushPropertiesTo
) {
1650 gfx::Size
layer_size(1000, 1000);
1652 scoped_ptr
<FakeDelegatedRendererLayerImpl
> delegated_renderer_layer_impl
=
1653 FakeDelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 5);
1654 delegated_renderer_layer_impl
->SetBounds(layer_size
);
1655 delegated_renderer_layer_impl
->SetDrawsContent(true);
1657 RenderPassList delegated_render_passes
;
1658 // |pass1| covers the whole layer.
1659 RenderPassId pass1_id
= RenderPassId(5, 0);
1660 AddRenderPass(&delegated_render_passes
,
1662 gfx::Rect(layer_size
),
1664 delegated_renderer_layer_impl
->SetFrameDataForRenderPasses(
1665 2.f
, delegated_render_passes
);
1666 EXPECT_EQ(0.5f
, delegated_renderer_layer_impl
->inverse_device_scale_factor());
1668 scoped_ptr
<DelegatedRendererLayerImpl
> other_layer
=
1669 DelegatedRendererLayerImpl::Create(host_impl_
->active_tree(), 6);
1671 delegated_renderer_layer_impl
->PushPropertiesTo(other_layer
.get());
1673 EXPECT_EQ(0.5f
, other_layer
->inverse_device_scale_factor());