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_layer_tree_host_impl.h"
13 #include "cc/test/fake_layer_tree_host_impl_client.h"
14 #include "cc/test/fake_output_surface.h"
15 #include "cc/test/fake_proxy.h"
16 #include "cc/test/fake_rendering_stats_instrumentation.h"
17 #include "cc/test/geometry_test_utils.h"
18 #include "cc/test/layer_test_common.h"
19 #include "cc/test/render_pass_test_common.h"
20 #include "cc/test/render_pass_test_utils.h"
21 #include "cc/test/test_shared_bitmap_manager.h"
22 #include "cc/test/test_web_graphics_context_3d.h"
23 #include "cc/trees/layer_tree_host_impl.h"
24 #include "cc/trees/layer_tree_impl.h"
25 #include "cc/trees/single_thread_proxy.h"
26 #include "testing/gtest/include/gtest/gtest.h"
27 #include "ui/gfx/frame_time.h"
28 #include "ui/gfx/transform.h"
33 class DelegatedRendererLayerImplTest : public testing::Test {
35 DelegatedRendererLayerImplTest()
37 always_impl_thread_and_main_thread_blocked_(&proxy_) {
38 LayerTreeSettings settings;
39 settings.minimum_occlusion_tracking_size = gfx::Size();
42 new FakeLayerTreeHostImpl(settings, &proxy_, &shared_bitmap_manager_));
43 host_impl_->InitializeRenderer(
44 FakeOutputSurface::Create3d().PassAs<OutputSurface>());
45 host_impl_->SetViewportSize(gfx::Size(10, 10));
50 DebugScopedSetImplThreadAndMainThreadBlocked
51 always_impl_thread_and_main_thread_blocked_;
52 TestSharedBitmapManager shared_bitmap_manager_;
53 scoped_ptr<LayerTreeHostImpl> host_impl_;
56 class DelegatedRendererLayerImplTestSimple
57 : public DelegatedRendererLayerImplTest {
59 DelegatedRendererLayerImplTestSimple()
60 : DelegatedRendererLayerImplTest() {
61 scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
62 host_impl_->active_tree(), 1).PassAs<LayerImpl>();
63 scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
64 host_impl_->active_tree(), 2).PassAs<LayerImpl>();
65 scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
66 host_impl_->active_tree(), 3).PassAs<LayerImpl>();
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));
73 layer_before->SetPosition(gfx::Point(20, 20));
74 layer_before->SetBounds(gfx::Size(14, 14));
75 layer_before->SetContentBounds(gfx::Size(14, 14));
76 layer_before->SetDrawsContent(true);
77 layer_before->SetForceRenderSurface(true);
79 layer_after->SetPosition(gfx::Point(5, 5));
80 layer_after->SetBounds(gfx::Size(15, 15));
81 layer_after->SetContentBounds(gfx::Size(15, 15));
82 layer_after->SetDrawsContent(true);
83 layer_after->SetForceRenderSurface(true);
85 delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
86 delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
87 delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
88 delegated_renderer_layer->SetDrawsContent(true);
89 gfx::Transform transform;
90 transform.Translate(1.0, 1.0);
91 delegated_renderer_layer->SetTransform(transform);
93 RenderPassList delegated_render_passes;
94 TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
96 gfx::Rect(6, 6, 6, 6),
97 gfx::Transform(1, 0, 0, 1, 5, 6));
98 AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
99 TestRenderPass* pass2 = AddRenderPass(&delegated_render_passes,
100 RenderPass::Id(9, 7),
101 gfx::Rect(7, 7, 7, 7),
102 gfx::Transform(1, 0, 0, 1, 7, 8));
103 AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
104 AddRenderPassQuad(pass2, pass1);
105 TestRenderPass* pass3 = AddRenderPass(&delegated_render_passes,
106 RenderPass::Id(9, 8),
107 gfx::Rect(0, 0, 8, 8),
108 gfx::Transform(1, 0, 0, 1, 9, 10));
109 AddRenderPassQuad(pass3, pass2);
110 delegated_renderer_layer->SetFrameDataForRenderPasses(
111 1.f, &delegated_render_passes);
113 // The RenderPasses should be taken by the layer.
114 EXPECT_EQ(0u, delegated_render_passes.size());
116 root_layer_ = root_layer.get();
117 layer_before_ = layer_before.get();
118 layer_after_ = layer_after.get();
119 delegated_renderer_layer_ = delegated_renderer_layer.get();
121 // Force the delegated RenderPasses to come before the RenderPass from
123 layer_after->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
124 root_layer->AddChild(layer_after.Pass());
126 // Get the RenderPass generated by layer_before to come before the delegated
128 root_layer->AddChild(layer_before.Pass());
129 host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
133 LayerImpl* root_layer_;
134 LayerImpl* layer_before_;
135 LayerImpl* layer_after_;
136 DelegatedRendererLayerImpl* delegated_renderer_layer_;
139 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
140 LayerTreeHostImpl::FrameData frame;
141 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
143 // Each non-DelegatedRendererLayer added one RenderPass. The
144 // DelegatedRendererLayer added two contributing passes.
145 ASSERT_EQ(5u, frame.render_passes.size());
147 // The DelegatedRendererLayer should have added its contributing RenderPasses
149 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
150 EXPECT_EQ(1, frame.render_passes[1]->id.index);
151 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
152 EXPECT_EQ(2, frame.render_passes[2]->id.index);
153 // And all other RenderPasses should be non-delegated.
154 EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
155 EXPECT_EQ(0, frame.render_passes[0]->id.index);
156 EXPECT_NE(4, frame.render_passes[3]->id.layer_id);
157 EXPECT_EQ(0, frame.render_passes[3]->id.index);
158 EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
159 EXPECT_EQ(0, frame.render_passes[4]->id.index);
161 // The DelegatedRendererLayer should have added its RenderPasses to the frame
163 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
164 frame.render_passes[1]->output_rect.ToString());
165 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
166 frame.render_passes[2]->output_rect.ToString());
168 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
169 host_impl_->DidDrawAllLayers(frame);
172 TEST_F(DelegatedRendererLayerImplTestSimple,
173 AddsQuadsToContributingRenderPasses) {
174 LayerTreeHostImpl::FrameData frame;
175 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
177 // Each non-DelegatedRendererLayer added one RenderPass. The
178 // DelegatedRendererLayer added two contributing passes.
179 ASSERT_EQ(5u, frame.render_passes.size());
181 // The DelegatedRendererLayer should have added its contributing RenderPasses
183 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
184 EXPECT_EQ(1, frame.render_passes[1]->id.index);
185 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
186 EXPECT_EQ(2, frame.render_passes[2]->id.index);
188 // The DelegatedRendererLayer should have added copies of its quads to
189 // contributing RenderPasses.
190 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
191 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
192 frame.render_passes[1]->quad_list[0]->rect.ToString());
194 // Verify it added the right quads.
195 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
196 EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
197 frame.render_passes[2]->quad_list[0]->rect.ToString());
198 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
199 frame.render_passes[2]->quad_list[1]->rect.ToString());
200 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
201 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
202 frame.render_passes[1]->quad_list[0]->rect.ToString());
204 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
205 host_impl_->DidDrawAllLayers(frame);
208 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
209 LayerTreeHostImpl::FrameData frame;
210 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
212 // Each non-DelegatedRendererLayer added one RenderPass. The
213 // DelegatedRendererLayer added two contributing passes.
214 ASSERT_EQ(5u, frame.render_passes.size());
216 // The layer's target is the RenderPass from layer_after_.
217 EXPECT_EQ(RenderPass::Id(3, 0), frame.render_passes[3]->id);
219 // The DelegatedRendererLayer should have added copies of quads in its root
220 // RenderPass to its target RenderPass. The layer_after_ also adds one quad.
221 ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
223 // Verify it added the right quads.
224 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
225 frame.render_passes[3]->quad_list[0]->rect.ToString());
227 // Its target layer should have a quad as well.
228 EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
229 frame.render_passes[3]->quad_list[1]->rect.ToString());
231 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
232 host_impl_->DidDrawAllLayers(frame);
235 TEST_F(DelegatedRendererLayerImplTestSimple,
236 QuadsFromRootRenderPassAreModifiedForTheTarget) {
237 LayerTreeHostImpl::FrameData frame;
238 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
240 // Each non-DelegatedRendererLayer added one RenderPass. The
241 // DelegatedRendererLayer added two contributing passes.
242 ASSERT_EQ(5u, frame.render_passes.size());
244 // The DelegatedRendererLayer is at position 3,3 compared to its target, and
245 // has a translation transform of 1,1. So its root RenderPass' quads should
246 // all be transformed by that combined amount.
247 gfx::Transform transform;
248 transform.Translate(4.0, 4.0);
249 EXPECT_TRANSFORMATION_MATRIX_EQ(
250 transform, frame.render_passes[3]->quad_list[0]->quadTransform());
252 // Quads from non-root RenderPasses should not be shifted though.
253 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
254 EXPECT_TRANSFORMATION_MATRIX_EQ(
255 gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
256 EXPECT_TRANSFORMATION_MATRIX_EQ(
257 gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
258 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
259 EXPECT_TRANSFORMATION_MATRIX_EQ(
260 gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
262 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
263 host_impl_->DidDrawAllLayers(frame);
266 TEST_F(DelegatedRendererLayerImplTestSimple, RenderPassTransformIsModified) {
267 LayerTreeHostImpl::FrameData frame;
268 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
270 // The delegated layer has a surface between it and the root.
271 EXPECT_TRUE(delegated_renderer_layer_->render_target()->parent());
273 // Each non-DelegatedRendererLayer added one RenderPass. The
274 // DelegatedRendererLayer added two contributing passes.
275 ASSERT_EQ(5u, frame.render_passes.size());
277 // The DelegatedRendererLayer is at position 9,9 compared to the root, so all
278 // render pass' transforms to the root should be shifted by this amount.
279 gfx::Transform transform;
280 transform.Translate(9.0, 9.0);
282 // The first contributing surface has a translation of 5, 6.
283 gfx::Transform five_six(1, 0, 0, 1, 5, 6);
285 // The second contributing surface has a translation of 7, 8.
286 gfx::Transform seven_eight(1, 0, 0, 1, 7, 8);
288 EXPECT_TRANSFORMATION_MATRIX_EQ(
289 transform * five_six, frame.render_passes[1]->transform_to_root_target);
290 EXPECT_TRANSFORMATION_MATRIX_EQ(
291 transform * seven_eight,
292 frame.render_passes[2]->transform_to_root_target);
294 host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
295 host_impl_->DidDrawAllLayers(frame);
298 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
299 LayerTreeHostImpl::FrameData frame;
300 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
302 // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
303 // has no need to be a RenderSurface for the quads it carries.
304 EXPECT_FALSE(delegated_renderer_layer_->render_surface());
306 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
307 host_impl_->DidDrawAllLayers(frame);
310 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
311 delegated_renderer_layer_->SetOpacity(0.5f);
313 LayerTreeHostImpl::FrameData frame;
314 FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
315 host_impl_->active_tree()->root_layer());
316 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
318 // This test case has quads from multiple layers in the delegated renderer, so
319 // if the DelegatedRendererLayer has opacity < 1, it should end up with a
321 EXPECT_TRUE(delegated_renderer_layer_->render_surface());
323 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
324 host_impl_->DidDrawAllLayers(frame);
327 TEST_F(DelegatedRendererLayerImplTestSimple,
328 DoesOwnARenderSurfaceForTransform) {
329 gfx::Transform rotation;
330 rotation.RotateAboutZAxis(30.0);
331 delegated_renderer_layer_->SetTransform(rotation);
333 LayerTreeHostImpl::FrameData frame;
334 FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
335 host_impl_->active_tree()->root_layer());
336 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
338 // This test case has quads from multiple layers in the delegated renderer, so
339 // if the DelegatedRendererLayer has opacity < 1, it should end up with a
341 EXPECT_TRUE(delegated_renderer_layer_->render_surface());
343 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
344 host_impl_->DidDrawAllLayers(frame);
347 class DelegatedRendererLayerImplTestOwnSurface
348 : public DelegatedRendererLayerImplTestSimple {
350 DelegatedRendererLayerImplTestOwnSurface()
351 : DelegatedRendererLayerImplTestSimple() {
352 delegated_renderer_layer_->SetForceRenderSurface(true);
356 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
357 LayerTreeHostImpl::FrameData frame;
358 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
360 // Each non-DelegatedRendererLayer added one RenderPass. The
361 // DelegatedRendererLayer added two contributing passes and its owned surface
363 ASSERT_EQ(6u, frame.render_passes.size());
365 // The DelegatedRendererLayer should have added its contributing RenderPasses
367 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
368 EXPECT_EQ(1, frame.render_passes[1]->id.index);
369 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
370 EXPECT_EQ(2, frame.render_passes[2]->id.index);
371 // The DelegatedRendererLayer should have added a RenderPass for its surface
373 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
374 EXPECT_EQ(0, frame.render_passes[3]->id.index);
375 // And all other RenderPasses should be non-delegated.
376 EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
377 EXPECT_EQ(0, frame.render_passes[0]->id.index);
378 EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
379 EXPECT_EQ(0, frame.render_passes[4]->id.index);
380 EXPECT_NE(4, frame.render_passes[5]->id.layer_id);
381 EXPECT_EQ(0, frame.render_passes[5]->id.index);
383 // The DelegatedRendererLayer should have added its RenderPasses to the frame
385 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
386 frame.render_passes[1]->output_rect.ToString());
387 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
388 frame.render_passes[2]->output_rect.ToString());
390 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
391 host_impl_->DidDrawAllLayers(frame);
394 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
395 AddsQuadsToContributingRenderPasses) {
396 LayerTreeHostImpl::FrameData frame;
397 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
399 // Each non-DelegatedRendererLayer added one RenderPass. The
400 // DelegatedRendererLayer added two contributing passes and its owned surface
402 ASSERT_EQ(6u, frame.render_passes.size());
404 // The DelegatedRendererLayer should have added its contributing RenderPasses
406 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
407 EXPECT_EQ(1, frame.render_passes[1]->id.index);
408 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
409 EXPECT_EQ(2, frame.render_passes[2]->id.index);
411 // The DelegatedRendererLayer should have added copies of its quads to
412 // contributing RenderPasses.
413 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
414 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
415 frame.render_passes[1]->quad_list[0]->rect.ToString());
417 // Verify it added the right quads.
418 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
419 EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
420 frame.render_passes[2]->quad_list[0]->rect.ToString());
421 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
422 frame.render_passes[2]->quad_list[1]->rect.ToString());
423 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
424 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
425 frame.render_passes[1]->quad_list[0]->rect.ToString());
427 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
428 host_impl_->DidDrawAllLayers(frame);
431 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
432 LayerTreeHostImpl::FrameData frame;
433 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
435 // Each non-DelegatedRendererLayer added one RenderPass. The
436 // DelegatedRendererLayer added two contributing passes and its owned surface
438 ASSERT_EQ(6u, frame.render_passes.size());
440 // The layer's target is the RenderPass owned by itself.
441 EXPECT_EQ(RenderPass::Id(4, 0), frame.render_passes[3]->id);
443 // The DelegatedRendererLayer should have added copies of quads in its root
444 // RenderPass to its target RenderPass.
445 // The layer_after also adds one quad.
446 ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
448 // Verify it added the right quads.
449 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
450 frame.render_passes[3]->quad_list[0]->rect.ToString());
452 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
453 host_impl_->DidDrawAllLayers(frame);
456 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
457 QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
458 LayerTreeHostImpl::FrameData frame;
459 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
461 // Each non-DelegatedRendererLayer added one RenderPass. The
462 // DelegatedRendererLayer added two contributing passes and its owned surface
464 ASSERT_EQ(6u, frame.render_passes.size());
466 // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
467 // RenderPass' quads do not need to be translated at all.
468 EXPECT_TRANSFORMATION_MATRIX_EQ(
469 gfx::Transform(), frame.render_passes[3]->quad_list[0]->quadTransform());
471 // Quads from non-root RenderPasses should not be shifted either.
472 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
473 EXPECT_TRANSFORMATION_MATRIX_EQ(
474 gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
475 EXPECT_TRANSFORMATION_MATRIX_EQ(
476 gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
477 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
478 EXPECT_TRANSFORMATION_MATRIX_EQ(
479 gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
481 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
482 host_impl_->DidDrawAllLayers(frame);
485 class DelegatedRendererLayerImplTestTransform
486 : public DelegatedRendererLayerImplTest {
488 DelegatedRendererLayerImplTestTransform()
489 : root_delegated_render_pass_is_clipped_(false),
490 delegated_device_scale_factor_(2.f) {}
493 host_impl_->SetDeviceScaleFactor(2.f);
495 scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
496 host_impl_->active_tree(), 1);
497 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
498 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
500 host_impl_->SetViewportSize(gfx::Size(200, 200));
501 root_layer->SetBounds(gfx::Size(100, 100));
503 delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
504 delegated_renderer_layer->SetBounds(gfx::Size(75, 75));
505 delegated_renderer_layer->SetContentBounds(gfx::Size(75, 75));
506 delegated_renderer_layer->SetDrawsContent(true);
507 gfx::Transform transform;
508 transform.Scale(2.0, 2.0);
509 transform.Translate(8.0, 8.0);
510 delegated_renderer_layer->SetTransform(transform);
512 RenderPassList delegated_render_passes;
514 gfx::Size child_pass_content_bounds(7, 7);
515 gfx::Rect child_pass_rect(20, 20, 7, 7);
516 gfx::Transform child_pass_transform;
517 child_pass_transform.Scale(0.8f, 0.8f);
518 child_pass_transform.Translate(9.0, 9.0);
519 gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
520 bool child_pass_clipped = false;
523 TestRenderPass* pass = AddRenderPass(
524 &delegated_render_passes,
525 RenderPass::Id(10, 7),
528 SharedQuadState* shared_quad_state =
529 pass->CreateAndAppendSharedQuadState();
530 shared_quad_state->SetAll(child_pass_transform,
531 child_pass_content_bounds,
533 child_pass_clip_rect,
536 SkXfermode::kSrcOver_Mode,
539 SolidColorDrawQuad* color_quad;
540 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
541 color_quad->SetNew(shared_quad_state,
542 gfx::Rect(20, 20, 3, 7),
543 gfx::Rect(20, 20, 3, 7),
547 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
548 color_quad->SetNew(shared_quad_state,
549 gfx::Rect(23, 20, 4, 7),
550 gfx::Rect(23, 20, 4, 7),
555 gfx::Size root_pass_content_bounds(100, 100);
556 gfx::Rect root_pass_rect(0, 0, 100, 100);
557 gfx::Transform root_pass_transform;
558 root_pass_transform.Scale(1.5, 1.5);
559 root_pass_transform.Translate(7.0, 7.0);
560 gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
561 bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
563 TestRenderPass* pass = AddRenderPass(
564 &delegated_render_passes,
565 RenderPass::Id(9, 6),
568 SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState();
569 shared_quad_state->SetAll(root_pass_transform,
570 root_pass_content_bounds,
575 SkXfermode::kSrcOver_Mode,
578 RenderPassDrawQuad* render_pass_quad =
579 pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
580 render_pass_quad->SetNew(
582 gfx::Rect(5, 5, 7, 7), // quad_rect
583 gfx::Rect(5, 5, 7, 7), // visible_rect
584 RenderPass::Id(10, 7), // render_pass_id
585 0, // mask_resource_id
586 gfx::RectF(), // mask_uv_rect
587 FilterOperations(), // filters
588 gfx::Vector2dF(), // filters_scale
589 FilterOperations()); // background_filters
591 SolidColorDrawQuad* color_quad;
592 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
593 color_quad->SetNew(shared_quad_state,
594 gfx::Rect(0, 0, 10, 10),
595 gfx::Rect(0, 0, 10, 10),
599 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
600 color_quad->SetNew(shared_quad_state,
601 gfx::Rect(0, 10, 10, 10),
602 gfx::Rect(0, 10, 10, 10),
606 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
607 color_quad->SetNew(shared_quad_state,
608 gfx::Rect(10, 0, 10, 10),
609 gfx::Rect(10, 0, 10, 10),
613 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
614 color_quad->SetNew(shared_quad_state,
615 gfx::Rect(10, 10, 10, 10),
616 gfx::Rect(10, 10, 10, 10),
620 delegated_renderer_layer->SetFrameDataForRenderPasses(
621 delegated_device_scale_factor_, &delegated_render_passes);
623 // The RenderPasses should be taken by the layer.
624 EXPECT_EQ(0u, delegated_render_passes.size());
626 root_layer_ = root_layer.get();
627 delegated_renderer_layer_ = delegated_renderer_layer.get();
629 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
630 host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
633 void VerifyRenderPasses(
634 const LayerTreeHostImpl::FrameData& frame,
635 size_t num_render_passes,
636 const SharedQuadState** root_delegated_shared_quad_state,
637 const SharedQuadState** contrib_delegated_shared_quad_state) {
638 ASSERT_EQ(num_render_passes, frame.render_passes.size());
639 // The contributing render pass in the DelegatedRendererLayer.
640 EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
641 EXPECT_EQ(1, frame.render_passes[0]->id.index);
642 // The root render pass.
643 EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
644 EXPECT_EQ(0, frame.render_passes.back()->id.index);
646 const QuadList& contrib_delegated_quad_list =
647 frame.render_passes[0]->quad_list;
648 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
650 const QuadList& root_delegated_quad_list =
651 frame.render_passes[1]->quad_list;
652 ASSERT_EQ(5u, root_delegated_quad_list.size());
654 // All quads in a render pass should share the same state.
655 *contrib_delegated_shared_quad_state =
656 contrib_delegated_quad_list[0]->shared_quad_state;
657 EXPECT_EQ(*contrib_delegated_shared_quad_state,
658 contrib_delegated_quad_list[1]->shared_quad_state);
660 *root_delegated_shared_quad_state =
661 root_delegated_quad_list[0]->shared_quad_state;
662 EXPECT_EQ(*root_delegated_shared_quad_state,
663 root_delegated_quad_list[1]->shared_quad_state);
664 EXPECT_EQ(*root_delegated_shared_quad_state,
665 root_delegated_quad_list[2]->shared_quad_state);
666 EXPECT_EQ(*root_delegated_shared_quad_state,
667 root_delegated_quad_list[3]->shared_quad_state);
668 EXPECT_EQ(*root_delegated_shared_quad_state,
669 root_delegated_quad_list[4]->shared_quad_state);
671 EXPECT_NE(*contrib_delegated_shared_quad_state,
672 *root_delegated_shared_quad_state);
676 LayerImpl* root_layer_;
677 DelegatedRendererLayerImpl* delegated_renderer_layer_;
678 bool root_delegated_render_pass_is_clipped_;
679 float delegated_device_scale_factor_;
682 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
683 root_delegated_render_pass_is_clipped_ = false;
686 LayerTreeHostImpl::FrameData frame;
687 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
689 const SharedQuadState* root_delegated_shared_quad_state = NULL;
690 const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
694 &root_delegated_shared_quad_state,
695 &contrib_delegated_shared_quad_state);
697 // When the quads don't have a clip of their own, the clip rect is set to
698 // the drawable_content_rect of the delegated renderer layer.
699 EXPECT_EQ(delegated_renderer_layer_->drawable_content_rect().ToString(),
700 root_delegated_shared_quad_state->clip_rect.ToString());
702 // Even though the quads in the root pass have no clip of their own, they
703 // inherit the clip rect from the delegated renderer layer if it does not
705 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
707 gfx::Transform expected;
708 // Device scale factor.
709 expected.Scale(2.0, 2.0);
710 // This is the transform from the layer's space to its target.
711 expected.Translate(20, 20);
712 expected.Scale(2.0, 2.0);
713 expected.Translate(8.0, 8.0);
714 // This is the transform within the source frame.
715 // Inverse device scale factor to go from physical space to layer space.
716 expected.Scale(0.5, 0.5);
717 expected.Scale(1.5, 1.5);
718 expected.Translate(7.0, 7.0);
719 EXPECT_TRANSFORMATION_MATRIX_EQ(
720 expected, root_delegated_shared_quad_state->content_to_target_transform);
722 // The contributing render pass should not be transformed from its input.
723 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
724 contrib_delegated_shared_quad_state->clip_rect.ToString());
725 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
726 expected.MakeIdentity();
727 expected.Scale(0.8f, 0.8f);
728 expected.Translate(9.0, 9.0);
729 EXPECT_TRANSFORMATION_MATRIX_EQ(
731 contrib_delegated_shared_quad_state->content_to_target_transform);
733 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
734 host_impl_->DidDrawAllLayers(frame);
737 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
738 root_delegated_render_pass_is_clipped_ = true;
741 LayerTreeHostImpl::FrameData frame;
742 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
744 const SharedQuadState* root_delegated_shared_quad_state = NULL;
745 const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
749 &root_delegated_shared_quad_state,
750 &contrib_delegated_shared_quad_state);
752 // Since the quads have a clip_rect it should be modified by delegated
753 // renderer layer's draw_transform.
754 // The position of the resulting clip_rect is:
755 // (clip rect position (10) * inverse dsf (1/2) + translate (8)) *
756 // layer scale (2) + layer position (20) = 46
757 // The device scale is 2, so everything gets doubled, giving 92.
759 // The size is 35x35 scaled by the device scale.
760 EXPECT_EQ(gfx::Rect(92, 92, 70, 70).ToString(),
761 root_delegated_shared_quad_state->clip_rect.ToString());
763 // The quads had a clip and it should be preserved.
764 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
766 gfx::Transform expected;
767 // Device scale factor.
768 expected.Scale(2.0, 2.0);
769 // This is the transform from the layer's space to its target.
770 expected.Translate(20, 20);
771 expected.Scale(2.0, 2.0);
772 expected.Translate(8.0, 8.0);
773 // This is the transform within the source frame.
774 // Inverse device scale factor to go from physical space to layer space.
775 expected.Scale(0.5, 0.5);
776 expected.Scale(1.5, 1.5);
777 expected.Translate(7.0, 7.0);
778 EXPECT_TRANSFORMATION_MATRIX_EQ(
779 expected, root_delegated_shared_quad_state->content_to_target_transform);
781 // The contributing render pass should not be transformed from its input.
782 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
783 contrib_delegated_shared_quad_state->clip_rect.ToString());
784 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
785 expected.MakeIdentity();
786 expected.Scale(0.8f, 0.8f);
787 expected.Translate(9.0, 9.0);
788 EXPECT_TRANSFORMATION_MATRIX_EQ(
790 contrib_delegated_shared_quad_state->content_to_target_transform);
792 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
793 host_impl_->DidDrawAllLayers(frame);
796 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
797 root_delegated_render_pass_is_clipped_ = false;
800 delegated_renderer_layer_->SetForceRenderSurface(true);
802 LayerTreeHostImpl::FrameData frame;
803 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
805 const SharedQuadState* root_delegated_shared_quad_state = NULL;
806 const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
810 &root_delegated_shared_quad_state,
811 &contrib_delegated_shared_quad_state);
813 // When the layer owns a surface, then its position and translation are not
814 // a part of its draw transform.
815 EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
816 root_delegated_shared_quad_state->clip_rect.ToString());
818 // Since the layer owns a surface it doesn't need to clip its quads, so
819 // unclipped quads remain unclipped.
820 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
822 gfx::Transform expected;
823 // This is the transform within the source frame.
824 expected.Scale(1.5, 1.5);
825 expected.Translate(7.0, 7.0);
826 EXPECT_TRANSFORMATION_MATRIX_EQ(
827 expected, root_delegated_shared_quad_state->content_to_target_transform);
829 // The contributing render pass should not be transformed from its input.
830 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
831 contrib_delegated_shared_quad_state->clip_rect.ToString());
832 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
833 expected.MakeIdentity();
834 expected.Scale(0.8f, 0.8f);
835 expected.Translate(9.0, 9.0);
836 EXPECT_TRANSFORMATION_MATRIX_EQ(
838 contrib_delegated_shared_quad_state->content_to_target_transform);
840 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
841 host_impl_->DidDrawAllLayers(frame);
844 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
845 root_delegated_render_pass_is_clipped_ = true;
848 delegated_renderer_layer_->SetForceRenderSurface(true);
850 LayerTreeHostImpl::FrameData frame;
851 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
853 const SharedQuadState* root_delegated_shared_quad_state = NULL;
854 const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
858 &root_delegated_shared_quad_state,
859 &contrib_delegated_shared_quad_state);
861 // When the layer owns a surface, then its position and translation are not
862 // a part of its draw transform. The clip_rect should be preserved.
863 EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
864 root_delegated_shared_quad_state->clip_rect.ToString());
866 // The quads had a clip and it should be preserved.
867 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
869 gfx::Transform expected;
870 // This is the transform within the source frame.
871 expected.Scale(1.5, 1.5);
872 expected.Translate(7.0, 7.0);
873 EXPECT_TRANSFORMATION_MATRIX_EQ(
874 expected, root_delegated_shared_quad_state->content_to_target_transform);
876 // The contributing render pass should not be transformed from its input.
877 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
878 contrib_delegated_shared_quad_state->clip_rect.ToString());
879 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
880 expected.MakeIdentity();
881 expected.Scale(0.8f, 0.8f);
882 expected.Translate(9.0, 9.0);
883 EXPECT_TRANSFORMATION_MATRIX_EQ(
885 contrib_delegated_shared_quad_state->content_to_target_transform);
887 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
888 host_impl_->DidDrawAllLayers(frame);
891 TEST_F(DelegatedRendererLayerImplTestTransform, MismatchedDeviceScaleFactor) {
892 root_delegated_render_pass_is_clipped_ = true;
893 delegated_device_scale_factor_ = 1.3f;
897 LayerTreeHostImpl::FrameData frame;
898 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
900 const SharedQuadState* root_delegated_shared_quad_state = NULL;
901 const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
902 VerifyRenderPasses(frame,
904 &root_delegated_shared_quad_state,
905 &contrib_delegated_shared_quad_state);
907 // The parent tree's device scale factor is 2.0, but the child has submitted a
908 // frame with a device scale factor of 1.3. Absent any better option, the
909 // only thing we can do is scale from 1.3 -> 2.0.
911 gfx::Transform expected;
912 // Device scale factor (from parent).
913 expected.Scale(2.0, 2.0);
914 // This is the transform from the layer's space to its target.
915 expected.Translate(20, 20);
916 expected.Scale(2.0, 2.0);
917 expected.Translate(8.0, 8.0);
918 // This is the transform within the source frame.
919 // Inverse device scale factor (from child).
920 expected.Scale(1.0f / 1.3f, 1.0f / 1.3f);
921 expected.Scale(1.5, 1.5);
922 expected.Translate(7.0, 7.0);
923 EXPECT_TRANSFORMATION_MATRIX_EQ(
924 expected, root_delegated_shared_quad_state->content_to_target_transform);
926 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
927 host_impl_->DidDrawAllLayers(frame);
930 class DelegatedRendererLayerImplTestClip
931 : public DelegatedRendererLayerImplTest {
934 scoped_ptr<LayerImpl> root_layer =
935 LayerImpl::Create(host_impl_->active_tree(), 1);
936 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
937 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
938 scoped_ptr<LayerImpl> clip_layer =
939 LayerImpl::Create(host_impl_->active_tree(), 3);
940 scoped_ptr<LayerImpl> origin_layer =
941 LayerImpl::Create(host_impl_->active_tree(), 4);
943 host_impl_->SetViewportSize(gfx::Size(100, 100));
944 root_layer->SetBounds(gfx::Size(100, 100));
946 delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
947 delegated_renderer_layer->SetBounds(gfx::Size(50, 50));
948 delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50));
949 delegated_renderer_layer->SetDrawsContent(true);
951 RenderPassList delegated_render_passes;
953 gfx::Size child_pass_content_bounds(7, 7);
954 gfx::Rect child_pass_rect(20, 20, 7, 7);
955 gfx::Transform child_pass_transform;
956 gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
957 bool child_pass_clipped = false;
960 TestRenderPass* pass = AddRenderPass(
961 &delegated_render_passes,
962 RenderPass::Id(10, 7),
965 SharedQuadState* shared_quad_state =
966 pass->CreateAndAppendSharedQuadState();
967 shared_quad_state->SetAll(child_pass_transform,
968 child_pass_content_bounds,
970 child_pass_clip_rect,
973 SkXfermode::kSrcOver_Mode,
976 SolidColorDrawQuad* color_quad;
977 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
978 color_quad->SetNew(shared_quad_state,
979 gfx::Rect(20, 20, 3, 7),
980 gfx::Rect(20, 20, 3, 7),
984 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
985 color_quad->SetNew(shared_quad_state,
986 gfx::Rect(23, 20, 4, 7),
987 gfx::Rect(23, 20, 4, 7),
992 gfx::Size root_pass_content_bounds(50, 50);
993 gfx::Rect root_pass_rect(0, 0, 50, 50);
994 gfx::Transform root_pass_transform;
995 gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
996 bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
998 TestRenderPass* pass = AddRenderPass(
999 &delegated_render_passes,
1000 RenderPass::Id(9, 6),
1003 SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState();
1004 shared_quad_state->SetAll(root_pass_transform,
1005 root_pass_content_bounds,
1007 root_pass_clip_rect,
1010 SkXfermode::kSrcOver_Mode,
1013 RenderPassDrawQuad* render_pass_quad =
1014 pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1015 render_pass_quad->SetNew(
1017 gfx::Rect(5, 5, 7, 7), // quad_rect
1018 gfx::Rect(5, 5, 7, 7), // visible_quad_rect
1019 RenderPass::Id(10, 7), // render_pass_id
1020 0, // mask_resource_id
1021 gfx::RectF(), // mask_uv_rect
1022 FilterOperations(), // filters
1023 gfx::Vector2dF(), // filters_scale
1024 FilterOperations()); // background_filters
1026 SolidColorDrawQuad* color_quad;
1027 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1028 color_quad->SetNew(shared_quad_state,
1029 gfx::Rect(0, 0, 10, 10),
1030 gfx::Rect(0, 0, 10, 10),
1034 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1035 color_quad->SetNew(shared_quad_state,
1036 gfx::Rect(0, 10, 10, 10),
1037 gfx::Rect(0, 10, 10, 10),
1041 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1042 color_quad->SetNew(shared_quad_state,
1043 gfx::Rect(10, 0, 10, 10),
1044 gfx::Rect(10, 0, 10, 10),
1048 color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1049 color_quad->SetNew(shared_quad_state,
1050 gfx::Rect(10, 10, 10, 10),
1051 gfx::Rect(10, 10, 10, 10),
1055 delegated_renderer_layer->SetFrameDataForRenderPasses(
1056 1.f, &delegated_render_passes);
1058 // The RenderPasses should be taken by the layer.
1059 EXPECT_EQ(0u, delegated_render_passes.size());
1061 root_layer_ = root_layer.get();
1062 delegated_renderer_layer_ = delegated_renderer_layer.get();
1064 if (clip_delegated_renderer_layer_) {
1065 gfx::Rect clip_rect(21, 27, 23, 21);
1067 clip_layer->SetPosition(clip_rect.origin());
1068 clip_layer->SetBounds(clip_rect.size());
1069 clip_layer->SetContentBounds(clip_rect.size());
1070 clip_layer->SetMasksToBounds(true);
1072 origin_layer->SetPosition(
1073 gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin()));
1075 origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1076 clip_layer->AddChild(origin_layer.Pass());
1077 root_layer->AddChild(clip_layer.Pass());
1079 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1082 host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
1086 LayerImpl* root_layer_;
1087 DelegatedRendererLayerImpl* delegated_renderer_layer_;
1088 bool root_delegated_render_pass_is_clipped_;
1089 bool clip_delegated_renderer_layer_;
1092 TEST_F(DelegatedRendererLayerImplTestClip,
1093 QuadsUnclipped_LayerUnclipped_NoSurface) {
1094 root_delegated_render_pass_is_clipped_ = false;
1095 clip_delegated_renderer_layer_ = false;
1098 LayerTreeHostImpl::FrameData frame;
1099 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1101 ASSERT_EQ(2u, frame.render_passes.size());
1102 const QuadList& contrib_delegated_quad_list =
1103 frame.render_passes[0]->quad_list;
1104 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1105 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1106 ASSERT_EQ(5u, root_delegated_quad_list.size());
1107 const SharedQuadState* root_delegated_shared_quad_state =
1108 root_delegated_quad_list[0]->shared_quad_state;
1110 // When the quads don't have a clip of their own, the clip rect is set to
1111 // the drawable_content_rect of the delegated renderer layer.
1112 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
1113 root_delegated_shared_quad_state->clip_rect.ToString());
1114 // Quads are clipped to the delegated renderer layer.
1115 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1117 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1118 host_impl_->DidDrawAllLayers(frame);
1121 TEST_F(DelegatedRendererLayerImplTestClip,
1122 QuadsClipped_LayerUnclipped_NoSurface) {
1123 root_delegated_render_pass_is_clipped_ = true;
1124 clip_delegated_renderer_layer_ = false;
1127 LayerTreeHostImpl::FrameData frame;
1128 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1130 ASSERT_EQ(2u, frame.render_passes.size());
1131 const QuadList& contrib_delegated_quad_list =
1132 frame.render_passes[0]->quad_list;
1133 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1134 const QuadList& root_delegated_quad_list =
1135 frame.render_passes[1]->quad_list;
1136 ASSERT_EQ(5u, root_delegated_quad_list.size());
1137 const SharedQuadState* root_delegated_shared_quad_state =
1138 root_delegated_quad_list[0]->shared_quad_state;
1140 // When the quads have a clip of their own, it is used.
1141 EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
1142 root_delegated_shared_quad_state->clip_rect.ToString());
1143 // Quads came with a clip rect.
1144 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1146 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1147 host_impl_->DidDrawAllLayers(frame);
1150 TEST_F(DelegatedRendererLayerImplTestClip,
1151 QuadsUnclipped_LayerClipped_NoSurface) {
1152 root_delegated_render_pass_is_clipped_ = false;
1153 clip_delegated_renderer_layer_ = true;
1156 LayerTreeHostImpl::FrameData frame;
1157 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1159 ASSERT_EQ(2u, frame.render_passes.size());
1160 const QuadList& contrib_delegated_quad_list =
1161 frame.render_passes[0]->quad_list;
1162 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1163 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1164 ASSERT_EQ(5u, root_delegated_quad_list.size());
1165 const SharedQuadState* root_delegated_shared_quad_state =
1166 root_delegated_quad_list[0]->shared_quad_state;
1168 // When the quads don't have a clip of their own, the clip rect is set to
1169 // the drawable_content_rect of the delegated renderer layer. When the layer
1170 // is clipped, that should be seen in the quads' clip_rect.
1171 EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
1172 root_delegated_shared_quad_state->clip_rect.ToString());
1173 // Quads are clipped to the delegated renderer layer.
1174 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1176 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1177 host_impl_->DidDrawAllLayers(frame);
1180 TEST_F(DelegatedRendererLayerImplTestClip,
1181 QuadsClipped_LayerClipped_NoSurface) {
1182 root_delegated_render_pass_is_clipped_ = true;
1183 clip_delegated_renderer_layer_ = true;
1186 LayerTreeHostImpl::FrameData frame;
1187 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1189 ASSERT_EQ(2u, frame.render_passes.size());
1190 const QuadList& contrib_delegated_quad_list =
1191 frame.render_passes[0]->quad_list;
1192 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1193 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1194 ASSERT_EQ(5u, root_delegated_quad_list.size());
1195 const SharedQuadState* root_delegated_shared_quad_state =
1196 root_delegated_quad_list[0]->shared_quad_state;
1198 // When the quads have a clip of their own, it is used, but it is
1199 // combined with the clip rect of the delegated renderer layer.
1200 EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(),
1201 root_delegated_shared_quad_state->clip_rect.ToString());
1202 // Quads came with a clip rect.
1203 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1205 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1206 host_impl_->DidDrawAllLayers(frame);
1209 TEST_F(DelegatedRendererLayerImplTestClip,
1210 QuadsUnclipped_LayerUnclipped_Surface) {
1211 root_delegated_render_pass_is_clipped_ = false;
1212 clip_delegated_renderer_layer_ = false;
1215 delegated_renderer_layer_->SetForceRenderSurface(true);
1217 LayerTreeHostImpl::FrameData frame;
1218 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1220 ASSERT_EQ(3u, 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 = frame.render_passes[1]->quad_list;
1225 ASSERT_EQ(5u, root_delegated_quad_list.size());
1226 const SharedQuadState* root_delegated_shared_quad_state =
1227 root_delegated_quad_list[0]->shared_quad_state;
1229 // When the layer owns a surface, the quads don't need to be clipped
1230 // further than they already specify. If they aren't clipped, then their
1231 // clip rect is ignored, and they are not set as clipped.
1232 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1234 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1235 host_impl_->DidDrawAllLayers(frame);
1238 TEST_F(DelegatedRendererLayerImplTestClip,
1239 QuadsClipped_LayerUnclipped_Surface) {
1240 root_delegated_render_pass_is_clipped_ = true;
1241 clip_delegated_renderer_layer_ = false;
1244 delegated_renderer_layer_->SetForceRenderSurface(true);
1246 LayerTreeHostImpl::FrameData frame;
1247 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1249 ASSERT_EQ(3u, frame.render_passes.size());
1250 const QuadList& contrib_delegated_quad_list =
1251 frame.render_passes[0]->quad_list;
1252 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1253 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1254 ASSERT_EQ(5u, root_delegated_quad_list.size());
1255 const SharedQuadState* root_delegated_shared_quad_state =
1256 root_delegated_quad_list[0]->shared_quad_state;
1258 // When the quads have a clip of their own, it is used.
1259 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1260 root_delegated_shared_quad_state->clip_rect.ToString());
1261 // Quads came with a clip rect.
1262 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1264 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1265 host_impl_->DidDrawAllLayers(frame);
1268 TEST_F(DelegatedRendererLayerImplTestClip,
1269 QuadsUnclipped_LayerClipped_Surface) {
1270 root_delegated_render_pass_is_clipped_ = false;
1271 clip_delegated_renderer_layer_ = true;
1274 delegated_renderer_layer_->SetForceRenderSurface(true);
1276 LayerTreeHostImpl::FrameData frame;
1277 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1279 ASSERT_EQ(3u, frame.render_passes.size());
1280 const QuadList& contrib_delegated_quad_list =
1281 frame.render_passes[0]->quad_list;
1282 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1283 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1284 ASSERT_EQ(5u, root_delegated_quad_list.size());
1285 const SharedQuadState* root_delegated_shared_quad_state =
1286 root_delegated_quad_list[0]->shared_quad_state;
1288 // When the layer owns a surface, the quads don't need to be clipped
1289 // further than they already specify. If they aren't clipped, then their
1290 // clip rect is ignored, and they are not set as clipped.
1291 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1293 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1294 host_impl_->DidDrawAllLayers(frame);
1297 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
1298 root_delegated_render_pass_is_clipped_ = true;
1299 clip_delegated_renderer_layer_ = true;
1302 delegated_renderer_layer_->SetForceRenderSurface(true);
1304 LayerTreeHostImpl::FrameData frame;
1305 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1307 ASSERT_EQ(3u, frame.render_passes.size());
1308 const QuadList& contrib_delegated_quad_list =
1309 frame.render_passes[0]->quad_list;
1310 ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1311 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1312 ASSERT_EQ(5u, root_delegated_quad_list.size());
1313 const SharedQuadState* root_delegated_shared_quad_state =
1314 root_delegated_quad_list[0]->shared_quad_state;
1316 // When the quads have a clip of their own, it is used, but it is
1317 // combined with the clip rect of the delegated renderer layer. If the
1318 // layer owns a surface, then it does not have a clip rect of its own.
1319 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1320 root_delegated_shared_quad_state->clip_rect.ToString());
1321 // Quads came with a clip rect.
1322 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1324 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1325 host_impl_->DidDrawAllLayers(frame);
1328 TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
1329 scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
1330 host_impl_->active_tree(), 1).PassAs<LayerImpl>();
1331 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
1332 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
1334 host_impl_->SetViewportSize(gfx::Size(100, 100));
1336 delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
1337 delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
1338 delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
1339 delegated_renderer_layer->SetDrawsContent(true);
1341 RenderPassList delegated_render_passes;
1342 TestRenderPass* pass1 = AddRenderPass(
1343 &delegated_render_passes,
1344 RenderPass::Id(9, 6),
1345 gfx::Rect(0, 0, 10, 10),
1347 AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
1349 // This render pass isn't part of the frame.
1350 scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create());
1351 missing_pass->SetNew(RenderPass::Id(9, 7),
1352 gfx::Rect(7, 7, 7, 7),
1353 gfx::Rect(7, 7, 7, 7),
1356 // But a render pass quad refers to it.
1357 AddRenderPassQuad(pass1, missing_pass.get());
1359 delegated_renderer_layer->SetFrameDataForRenderPasses(
1360 1.f, &delegated_render_passes);
1362 // The RenderPasses should be taken by the layer.
1363 EXPECT_EQ(0u, delegated_render_passes.size());
1365 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1366 host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
1368 LayerTreeHostImpl::FrameData frame;
1369 EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1371 // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
1372 ASSERT_EQ(1u, frame.render_passes.size());
1373 ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
1374 EXPECT_EQ(DrawQuad::SOLID_COLOR,
1375 frame.render_passes[0]->quad_list[0]->material);
1377 host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
1378 host_impl_->DidDrawAllLayers(frame);
1381 TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
1382 gfx::Size layer_size(1000, 1000);
1383 gfx::Size viewport_size(1000, 1000);
1384 gfx::Rect quad_rect(200, 300, 400, 500);
1386 gfx::Transform transform;
1387 transform.Translate(11.0, 0.0);
1389 LayerTestCommon::LayerImplTest impl;
1391 FakeDelegatedRendererLayerImpl* delegated_renderer_layer_impl =
1392 impl.AddChildToRoot<FakeDelegatedRendererLayerImpl>();
1393 delegated_renderer_layer_impl->SetBounds(layer_size);
1394 delegated_renderer_layer_impl->SetContentBounds(layer_size);
1395 delegated_renderer_layer_impl->SetDrawsContent(true);
1397 RenderPassList delegated_render_passes;
1398 // pass2 is just the size of the quad. It contributes to |pass1| with a
1399 // translation of (11,0).
1400 RenderPass::Id pass2_id =
1401 delegated_renderer_layer_impl->FirstContributingRenderPassId();
1402 TestRenderPass* pass2 =
1403 AddRenderPass(&delegated_render_passes, pass2_id, quad_rect, transform);
1404 AddQuad(pass2, gfx::Rect(quad_rect.size()), SK_ColorRED);
1405 // |pass1| covers the whole layer.
1406 RenderPass::Id pass1_id = RenderPass::Id(impl.root_layer()->id(), 0);
1407 TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
1409 gfx::Rect(layer_size),
1411 AddRenderPassQuad(pass1, pass2, 0, FilterOperations(), transform);
1412 delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
1413 1.f, &delegated_render_passes);
1415 impl.CalcDrawProps(viewport_size);
1417 // The |quad_rect| translated by the |transform|.
1418 gfx::Rect quad_screen_rect = quad_rect + gfx::Vector2d(11, 0);
1421 SCOPED_TRACE("No occlusion");
1425 SCOPED_TRACE("Root render pass");
1426 impl.AppendQuadsForPassWithOcclusion(
1427 delegated_renderer_layer_impl, pass1_id, occluded);
1428 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1430 ASSERT_EQ(1u, impl.quad_list().size());
1431 EXPECT_EQ(DrawQuad::RENDER_PASS, impl.quad_list()[0]->material);
1434 SCOPED_TRACE("Contributing render pass");
1435 impl.AppendQuadsForPassWithOcclusion(
1436 delegated_renderer_layer_impl, pass2_id, occluded);
1437 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1438 gfx::Rect(quad_rect.size()));
1439 ASSERT_EQ(1u, impl.quad_list().size());
1440 EXPECT_EQ(DrawQuad::SOLID_COLOR, impl.quad_list()[0]->material);
1445 SCOPED_TRACE("Full occlusion");
1447 gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
1449 SCOPED_TRACE("Root render pass");
1450 impl.AppendQuadsForPassWithOcclusion(
1451 delegated_renderer_layer_impl, pass1_id, occluded);
1452 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1454 EXPECT_EQ(impl.quad_list().size(), 0u);
1457 gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
1458 // Move the occlusion to where it is in the contributing surface.
1459 occluded -= quad_rect.OffsetFromOrigin();
1461 SCOPED_TRACE("Contributing render pass");
1462 impl.AppendQuadsForPassWithOcclusion(
1463 delegated_renderer_layer_impl, pass2_id, occluded);
1464 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1466 EXPECT_EQ(impl.quad_list().size(), 0u);
1471 SCOPED_TRACE("Partial occlusion");
1473 gfx::Rect occluded(0, 0, 500, 1000);
1475 SCOPED_TRACE("Root render pass");
1476 impl.AppendQuadsForPassWithOcclusion(
1477 delegated_renderer_layer_impl, pass1_id, occluded);
1478 size_t partially_occluded_count = 0;
1479 LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
1483 &partially_occluded_count);
1484 // The layer outputs one quad, which is partially occluded.
1485 EXPECT_EQ(1u, impl.quad_list().size());
1486 EXPECT_EQ(1u, partially_occluded_count);
1489 gfx::Rect occluded(0, 0, 500, 1000);
1490 // Move the occlusion to where it is in the contributing surface.
1491 occluded -= quad_rect.OffsetFromOrigin() + gfx::Vector2d(11, 0);
1493 SCOPED_TRACE("Contributing render pass");
1494 impl.AppendQuadsForPassWithOcclusion(
1495 delegated_renderer_layer_impl, pass2_id, occluded);
1496 size_t partially_occluded_count = 0;
1497 LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
1499 gfx::Rect(quad_rect.size()),
1501 &partially_occluded_count);
1502 // The layer outputs one quad, which is partially occluded.
1503 EXPECT_EQ(1u, impl.quad_list().size());
1504 EXPECT_EQ(1u, partially_occluded_count);
1505 // The quad in the contributing surface is at (211,300) in the root.
1506 // The occlusion extends to 500 in the x-axis, pushing the left of the
1507 // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
1508 EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
1509 impl.quad_list()[0]->visible_rect.ToString());
1513 gfx::Rect occluded(0, 0, 500, 1000);
1514 // Move the occlusion to where it is in the contributing surface.
1515 occluded -= quad_rect.OffsetFromOrigin() + gfx::Vector2d(11, 0);
1517 SCOPED_TRACE("Contributing render pass with transformed root");
1519 delegated_renderer_layer_impl->SetTransform(transform);
1520 impl.CalcDrawProps(viewport_size);
1522 impl.AppendQuadsForPassWithOcclusion(
1523 delegated_renderer_layer_impl, pass2_id, occluded);
1524 size_t partially_occluded_count = 0;
1525 LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
1527 gfx::Rect(quad_rect.size()),
1529 &partially_occluded_count);
1530 // The layer outputs one quad, which is partially occluded.
1531 EXPECT_EQ(1u, impl.quad_list().size());
1532 EXPECT_EQ(1u, partially_occluded_count);
1533 // The quad in the contributing surface is at (222,300) in the transformed
1534 // root. The occlusion extends to 500 in the x-axis, pushing the left of the
1535 // visible part of the quad to 500 - 222 = 300 - 22 inside the quad.
1536 EXPECT_EQ(gfx::Rect(300 - 22, 0, 100 + 22, 500).ToString(),
1537 impl.quad_list()[0]->visible_rect.ToString());
1541 TEST_F(DelegatedRendererLayerImplTest, PushPropertiesTo) {
1542 gfx::Size layer_size(1000, 1000);
1544 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer_impl =
1545 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 5);
1546 delegated_renderer_layer_impl->SetBounds(layer_size);
1547 delegated_renderer_layer_impl->SetContentBounds(layer_size);
1548 delegated_renderer_layer_impl->SetDrawsContent(true);
1550 RenderPassList delegated_render_passes;
1551 // |pass1| covers the whole layer.
1552 RenderPass::Id pass1_id = RenderPass::Id(5, 0);
1553 AddRenderPass(&delegated_render_passes,
1555 gfx::Rect(layer_size),
1557 delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
1558 2.f, &delegated_render_passes);
1559 EXPECT_EQ(0.5f, delegated_renderer_layer_impl->inverse_device_scale_factor());
1561 scoped_ptr<DelegatedRendererLayerImpl> other_layer =
1562 DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
1564 delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
1566 EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());