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.
4
5#include "cc/layers/delegated_renderer_layer_impl.h"
6
7#include "cc/base/scoped_ptr_vector.h"
8#include "cc/layers/append_quads_data.h"
9#include "cc/layers/quad_sink.h"
10#include "cc/layers/solid_color_layer_impl.h"
11#include "cc/quads/render_pass_draw_quad.h"
12#include "cc/quads/solid_color_draw_quad.h"
13#include "cc/test/fake_delegated_renderer_layer_impl.h"
14#include "cc/test/fake_layer_tree_host_impl.h"
15#include "cc/test/fake_layer_tree_host_impl_client.h"
16#include "cc/test/fake_output_surface.h"
17#include "cc/test/fake_proxy.h"
18#include "cc/test/fake_rendering_stats_instrumentation.h"
19#include "cc/test/geometry_test_utils.h"
20#include "cc/test/mock_quad_culler.h"
21#include "cc/test/render_pass_test_common.h"
22#include "cc/test/render_pass_test_utils.h"
23#include "cc/test/test_web_graphics_context_3d.h"
24#include "cc/trees/layer_tree_host_impl.h"
25#include "cc/trees/layer_tree_impl.h"
26#include "cc/trees/single_thread_proxy.h"
27#include "testing/gtest/include/gtest/gtest.h"
28#include "ui/gfx/transform.h"
29
30namespace cc {
31namespace {
32
33class DelegatedRendererLayerImplTest : public testing::Test {
34 public:
35  DelegatedRendererLayerImplTest()
36      : proxy_(),
37        always_impl_thread_and_main_thread_blocked_(&proxy_) {
38    LayerTreeSettings settings;
39    settings.minimum_occlusion_tracking_size = gfx::Size();
40
41    host_impl_ = LayerTreeHostImpl::Create(settings,
42                                           &client_,
43                                           &proxy_,
44                                           &stats_instrumentation_);
45    host_impl_->InitializeRenderer(CreateFakeOutputSurface());
46    host_impl_->SetViewportSize(gfx::Size(10, 10));
47  }
48
49 protected:
50  FakeProxy proxy_;
51  FakeLayerTreeHostImplClient client_;
52  DebugScopedSetImplThreadAndMainThreadBlocked
53      always_impl_thread_and_main_thread_blocked_;
54  FakeRenderingStatsInstrumentation stats_instrumentation_;
55  scoped_ptr<LayerTreeHostImpl> host_impl_;
56};
57
58class DelegatedRendererLayerImplTestSimple
59    : public DelegatedRendererLayerImplTest {
60 public:
61  DelegatedRendererLayerImplTestSimple()
62      : DelegatedRendererLayerImplTest() {
63    scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
64        host_impl_->active_tree(), 1).PassAs<LayerImpl>();
65    scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
66        host_impl_->active_tree(), 2).PassAs<LayerImpl>();
67    scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
68        host_impl_->active_tree(), 3).PassAs<LayerImpl>();
69    scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
70        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
71
72    host_impl_->SetViewportSize(gfx::Size(100, 100));
73    root_layer->SetBounds(gfx::Size(100, 100));
74
75    layer_before->SetPosition(gfx::Point(20, 20));
76    layer_before->SetBounds(gfx::Size(14, 14));
77    layer_before->SetContentBounds(gfx::Size(14, 14));
78    layer_before->SetDrawsContent(true);
79    layer_before->SetForceRenderSurface(true);
80
81    layer_after->SetPosition(gfx::Point(5, 5));
82    layer_after->SetBounds(gfx::Size(15, 15));
83    layer_after->SetContentBounds(gfx::Size(15, 15));
84    layer_after->SetDrawsContent(true);
85    layer_after->SetForceRenderSurface(true);
86
87    delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
88    delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
89    delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
90    delegated_renderer_layer->SetDrawsContent(true);
91    gfx::Transform transform;
92    transform.Translate(1.0, 1.0);
93    delegated_renderer_layer->SetTransform(transform);
94
95    ScopedPtrVector<RenderPass> delegated_render_passes;
96    TestRenderPass* pass1 = AddRenderPass(
97        &delegated_render_passes,
98        RenderPass::Id(9, 6),
99        gfx::Rect(6, 6, 6, 6),
100        gfx::Transform());
101    AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
102    TestRenderPass* pass2 = AddRenderPass(
103        &delegated_render_passes,
104        RenderPass::Id(9, 7),
105        gfx::Rect(7, 7, 7, 7),
106        gfx::Transform());
107    AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
108    AddRenderPassQuad(pass2, pass1);
109    TestRenderPass* pass3 = AddRenderPass(
110        &delegated_render_passes,
111        RenderPass::Id(9, 8),
112        gfx::Rect(0, 0, 8, 8),
113        gfx::Transform());
114    AddRenderPassQuad(pass3, pass2);
115    delegated_renderer_layer->SetFrameDataForRenderPasses(
116        &delegated_render_passes);
117
118    // The RenderPasses should be taken by the layer.
119    EXPECT_EQ(0u, delegated_render_passes.size());
120
121    root_layer_ = root_layer.get();
122    layer_before_ = layer_before.get();
123    layer_after_ = layer_after.get();
124    delegated_renderer_layer_ = delegated_renderer_layer.get();
125
126    // Force the delegated RenderPasses to come before the RenderPass from
127    // layer_after.
128    layer_after->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
129    root_layer->AddChild(layer_after.Pass());
130
131    // Get the RenderPass generated by layer_before to come before the delegated
132    // RenderPasses.
133    root_layer->AddChild(layer_before.Pass());
134    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
135  }
136
137 protected:
138  LayerImpl* root_layer_;
139  LayerImpl* layer_before_;
140  LayerImpl* layer_after_;
141  DelegatedRendererLayerImpl* delegated_renderer_layer_;
142};
143
144TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
145  LayerTreeHostImpl::FrameData frame;
146  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
147
148  // Each non-DelegatedRendererLayer added one RenderPass. The
149  // DelegatedRendererLayer added two contributing passes.
150  ASSERT_EQ(5u, frame.render_passes.size());
151
152  // The DelegatedRendererLayer should have added its contributing RenderPasses
153  // to the frame.
154  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
155  EXPECT_EQ(1, frame.render_passes[1]->id.index);
156  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
157  EXPECT_EQ(2, frame.render_passes[2]->id.index);
158  // And all other RenderPasses should be non-delegated.
159  EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
160  EXPECT_EQ(0, frame.render_passes[0]->id.index);
161  EXPECT_NE(4, frame.render_passes[3]->id.layer_id);
162  EXPECT_EQ(0, frame.render_passes[3]->id.index);
163  EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
164  EXPECT_EQ(0, frame.render_passes[4]->id.index);
165
166  // The DelegatedRendererLayer should have added its RenderPasses to the frame
167  // in order.
168  EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
169            frame.render_passes[1]->output_rect.ToString());
170  EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
171            frame.render_passes[2]->output_rect.ToString());
172
173  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
174  host_impl_->DidDrawAllLayers(frame);
175}
176
177TEST_F(DelegatedRendererLayerImplTestSimple,
178       AddsQuadsToContributingRenderPasses) {
179  LayerTreeHostImpl::FrameData frame;
180  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
181
182  // Each non-DelegatedRendererLayer added one RenderPass. The
183  // DelegatedRendererLayer added two contributing passes.
184  ASSERT_EQ(5u, frame.render_passes.size());
185
186  // The DelegatedRendererLayer should have added its contributing RenderPasses
187  // to the frame.
188  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
189  EXPECT_EQ(1, frame.render_passes[1]->id.index);
190  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
191  EXPECT_EQ(2, frame.render_passes[2]->id.index);
192
193  // The DelegatedRendererLayer should have added copies of its quads to
194  // contributing RenderPasses.
195  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
196  EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
197            frame.render_passes[1]->quad_list[0]->rect.ToString());
198
199  // Verify it added the right quads.
200  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
201  EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
202            frame.render_passes[2]->quad_list[0]->rect.ToString());
203  EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
204            frame.render_passes[2]->quad_list[1]->rect.ToString());
205  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
206  EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
207            frame.render_passes[1]->quad_list[0]->rect.ToString());
208
209  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
210  host_impl_->DidDrawAllLayers(frame);
211}
212
213TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
214  LayerTreeHostImpl::FrameData frame;
215  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
216
217  // Each non-DelegatedRendererLayer added one RenderPass. The
218  // DelegatedRendererLayer added two contributing passes.
219  ASSERT_EQ(5u, frame.render_passes.size());
220
221  // The layer's target is the RenderPass from layer_after_.
222  EXPECT_EQ(RenderPass::Id(3, 0), frame.render_passes[3]->id);
223
224  // The DelegatedRendererLayer should have added copies of quads in its root
225  // RenderPass to its target RenderPass. The layer_after_ also adds one quad.
226  ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
227
228  // Verify it added the right quads.
229  EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
230            frame.render_passes[3]->quad_list[0]->rect.ToString());
231
232  // Its target layer should have a quad as well.
233  EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
234            frame.render_passes[3]->quad_list[1]->rect.ToString());
235
236  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
237  host_impl_->DidDrawAllLayers(frame);
238}
239
240TEST_F(DelegatedRendererLayerImplTestSimple,
241       QuadsFromRootRenderPassAreModifiedForTheTarget) {
242  LayerTreeHostImpl::FrameData frame;
243  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
244
245  // Each non-DelegatedRendererLayer added one RenderPass. The
246  // DelegatedRendererLayer added two contributing passes.
247  ASSERT_EQ(5u, frame.render_passes.size());
248
249  // The DelegatedRendererLayer is at position 3,3 compared to its target, and
250  // has a translation transform of 1,1. So its root RenderPass' quads should
251  // all be transformed by that combined amount.
252  // The DelegatedRendererLayer has a size of 10x10, but the root delegated
253  // RenderPass has a size of 8x8, so any quads should be scaled by 10/8.
254  gfx::Transform transform;
255  transform.Translate(4.0, 4.0);
256  transform.Scale(10.0 / 8.0, 10.0 / 8.0);
257  EXPECT_TRANSFORMATION_MATRIX_EQ(
258      transform, frame.render_passes[3]->quad_list[0]->quadTransform());
259
260  // Quads from non-root RenderPasses should not be shifted though.
261  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
262  EXPECT_TRANSFORMATION_MATRIX_EQ(
263      gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
264  EXPECT_TRANSFORMATION_MATRIX_EQ(
265      gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
266  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
267  EXPECT_TRANSFORMATION_MATRIX_EQ(
268      gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
269
270  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
271  host_impl_->DidDrawAllLayers(frame);
272}
273
274TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
275  LayerTreeHostImpl::FrameData frame;
276  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
277
278  // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
279  // has no need to be a RenderSurface for the quads it carries.
280  EXPECT_FALSE(delegated_renderer_layer_->render_surface());
281
282  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
283  host_impl_->DidDrawAllLayers(frame);
284}
285
286TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
287  delegated_renderer_layer_->SetOpacity(0.5f);
288
289  LayerTreeHostImpl::FrameData frame;
290  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
291
292  // This test case has quads from multiple layers in the delegated renderer, so
293  // if the DelegatedRendererLayer has opacity < 1, it should end up with a
294  // render surface.
295  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
296
297  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
298  host_impl_->DidDrawAllLayers(frame);
299}
300
301TEST_F(DelegatedRendererLayerImplTestSimple,
302       DoesOwnARenderSurfaceForTransform) {
303  gfx::Transform rotation;
304  rotation.RotateAboutZAxis(30.0);
305  delegated_renderer_layer_->SetTransform(rotation);
306
307  LayerTreeHostImpl::FrameData frame;
308  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
309
310  // This test case has quads from multiple layers in the delegated renderer, so
311  // if the DelegatedRendererLayer has opacity < 1, it should end up with a
312  // render surface.
313  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
314
315  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
316  host_impl_->DidDrawAllLayers(frame);
317}
318
319class DelegatedRendererLayerImplTestOwnSurface
320    : public DelegatedRendererLayerImplTestSimple {
321 public:
322  DelegatedRendererLayerImplTestOwnSurface()
323      : DelegatedRendererLayerImplTestSimple() {
324    delegated_renderer_layer_->SetForceRenderSurface(true);
325  }
326};
327
328TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
329  LayerTreeHostImpl::FrameData frame;
330  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
331
332  // Each non-DelegatedRendererLayer added one RenderPass. The
333  // DelegatedRendererLayer added two contributing passes and its owned surface
334  // added one pass.
335  ASSERT_EQ(6u, frame.render_passes.size());
336
337  // The DelegatedRendererLayer should have added its contributing RenderPasses
338  // to the frame.
339  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
340  EXPECT_EQ(1, frame.render_passes[1]->id.index);
341  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
342  EXPECT_EQ(2, frame.render_passes[2]->id.index);
343  // The DelegatedRendererLayer should have added a RenderPass for its surface
344  // to the frame.
345  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
346  EXPECT_EQ(0, frame.render_passes[3]->id.index);
347  // And all other RenderPasses should be non-delegated.
348  EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
349  EXPECT_EQ(0, frame.render_passes[0]->id.index);
350  EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
351  EXPECT_EQ(0, frame.render_passes[4]->id.index);
352  EXPECT_NE(4, frame.render_passes[5]->id.layer_id);
353  EXPECT_EQ(0, frame.render_passes[5]->id.index);
354
355  // The DelegatedRendererLayer should have added its RenderPasses to the frame
356  // in order.
357  EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
358            frame.render_passes[1]->output_rect.ToString());
359  EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
360            frame.render_passes[2]->output_rect.ToString());
361
362  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
363  host_impl_->DidDrawAllLayers(frame);
364}
365
366TEST_F(DelegatedRendererLayerImplTestOwnSurface,
367       AddsQuadsToContributingRenderPasses) {
368  LayerTreeHostImpl::FrameData frame;
369  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
370
371  // Each non-DelegatedRendererLayer added one RenderPass. The
372  // DelegatedRendererLayer added two contributing passes and its owned surface
373  // added one pass.
374  ASSERT_EQ(6u, frame.render_passes.size());
375
376  // The DelegatedRendererLayer should have added its contributing RenderPasses
377  // to the frame.
378  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
379  EXPECT_EQ(1, frame.render_passes[1]->id.index);
380  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
381  EXPECT_EQ(2, frame.render_passes[2]->id.index);
382
383  // The DelegatedRendererLayer should have added copies of its quads to
384  // contributing RenderPasses.
385  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
386  EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
387            frame.render_passes[1]->quad_list[0]->rect.ToString());
388
389  // Verify it added the right quads.
390  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
391  EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
392            frame.render_passes[2]->quad_list[0]->rect.ToString());
393  EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
394            frame.render_passes[2]->quad_list[1]->rect.ToString());
395  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
396  EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
397            frame.render_passes[1]->quad_list[0]->rect.ToString());
398
399  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
400  host_impl_->DidDrawAllLayers(frame);
401}
402
403TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
404  LayerTreeHostImpl::FrameData frame;
405  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
406
407  // Each non-DelegatedRendererLayer added one RenderPass. The
408  // DelegatedRendererLayer added two contributing passes and its owned surface
409  // added one pass.
410  ASSERT_EQ(6u, frame.render_passes.size());
411
412  // The layer's target is the RenderPass owned by itself.
413  EXPECT_EQ(RenderPass::Id(4, 0), frame.render_passes[3]->id);
414
415  // The DelegatedRendererLayer should have added copies of quads in its root
416  // RenderPass to its target RenderPass.
417  // The layer_after also adds one quad.
418  ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
419
420  // Verify it added the right quads.
421  EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
422            frame.render_passes[3]->quad_list[0]->rect.ToString());
423
424  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
425  host_impl_->DidDrawAllLayers(frame);
426}
427
428TEST_F(DelegatedRendererLayerImplTestOwnSurface,
429       QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
430  LayerTreeHostImpl::FrameData frame;
431  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
432
433  // Each non-DelegatedRendererLayer added one RenderPass. The
434  // DelegatedRendererLayer added two contributing passes and its owned surface
435  // added one pass.
436  ASSERT_EQ(6u, frame.render_passes.size());
437
438  // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
439  // RenderPass' quads do not need to be translated at all. However, they are
440  // scaled from the frame's size (8x8) to the layer's bounds (10x10).
441  gfx::Transform transform;
442  transform.Scale(10.0 / 8.0, 10.0 / 8.0);
443  EXPECT_TRANSFORMATION_MATRIX_EQ(
444      transform, frame.render_passes[3]->quad_list[0]->quadTransform());
445
446  // Quads from non-root RenderPasses should not be shifted either.
447  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
448  EXPECT_TRANSFORMATION_MATRIX_EQ(
449      gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
450  EXPECT_TRANSFORMATION_MATRIX_EQ(
451      gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
452  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
453  EXPECT_TRANSFORMATION_MATRIX_EQ(
454      gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
455
456  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
457  host_impl_->DidDrawAllLayers(frame);
458}
459
460class DelegatedRendererLayerImplTestTransform
461    : public DelegatedRendererLayerImplTest {
462 public:
463  void SetUpTest() {
464    host_impl_->SetDeviceScaleFactor(2.f);
465
466    scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
467        host_impl_->active_tree(), 1);
468    scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
469        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
470
471    host_impl_->SetViewportSize(gfx::Size(200, 200));
472    root_layer->SetBounds(gfx::Size(100, 100));
473
474    delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
475    delegated_renderer_layer->SetBounds(gfx::Size(30, 30));
476    delegated_renderer_layer->SetContentBounds(gfx::Size(30, 30));
477    delegated_renderer_layer->SetDrawsContent(true);
478    gfx::Transform transform;
479    transform.Scale(2.0, 2.0);
480    transform.Translate(8.0, 8.0);
481    delegated_renderer_layer->SetTransform(transform);
482
483    ScopedPtrVector<RenderPass> delegated_render_passes;
484
485    gfx::Size child_pass_content_bounds(7, 7);
486    gfx::Rect child_pass_rect(20, 20, 7, 7);
487    gfx::Transform child_pass_transform;
488    child_pass_transform.Scale(0.8, 0.8);
489    child_pass_transform.Translate(9.0, 9.0);
490    gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
491    bool child_pass_clipped = false;
492
493    {
494      TestRenderPass* pass = AddRenderPass(
495          &delegated_render_passes,
496          RenderPass::Id(10, 7),
497          child_pass_rect,
498          gfx::Transform());
499      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
500      AppendQuadsData data(pass->id);
501      SharedQuadState* shared_quad_state = quad_sink.UseSharedQuadState(
502          SharedQuadState::Create());
503      shared_quad_state->SetAll(
504          child_pass_transform,
505          child_pass_content_bounds,
506          child_pass_rect,
507          child_pass_clip_rect,
508          child_pass_clipped,
509          1.f);
510
511      scoped_ptr<SolidColorDrawQuad> color_quad;
512      color_quad = SolidColorDrawQuad::Create();
513      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false);
514      quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
515
516      color_quad = SolidColorDrawQuad::Create();
517      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false);
518      quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
519    }
520
521    gfx::Size root_pass_content_bounds(50, 50);
522    gfx::Rect root_pass_rect(0, 0, 50, 50);
523    gfx::Transform root_pass_transform;
524    root_pass_transform.Scale(1.5, 1.5);
525    root_pass_transform.Translate(7.0, 7.0);
526    gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
527    bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
528
529    TestRenderPass* pass = AddRenderPass(
530        &delegated_render_passes,
531        RenderPass::Id(9, 6),
532        root_pass_rect,
533        gfx::Transform());
534    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
535    AppendQuadsData data(pass->id);
536    SharedQuadState* shared_quad_state =
537        quad_sink.UseSharedQuadState(SharedQuadState::Create());
538    shared_quad_state->SetAll(
539        root_pass_transform,
540        root_pass_content_bounds,
541        root_pass_rect,
542        root_pass_clip_rect,
543        root_pass_clipped,
544        1.f);
545
546    scoped_ptr<RenderPassDrawQuad> render_pass_quad =
547        RenderPassDrawQuad::Create();
548    render_pass_quad->SetNew(
549        shared_quad_state,
550        gfx::Rect(5, 5, 7, 7),  // rect
551        RenderPass::Id(10, 7),  // render_pass_id
552        false,  // is_replica
553        0,  // mask_resource_id
554        child_pass_rect,  // contents_changed_since_last_frame
555        gfx::RectF(),  // mask_uv_rect
556        FilterOperations(),  // filters
557        skia::RefPtr<SkImageFilter>(),  // filter
558        FilterOperations());  // background_filters
559    quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data);
560
561    scoped_ptr<SolidColorDrawQuad> color_quad;
562    color_quad = SolidColorDrawQuad::Create();
563    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false);
564    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
565
566    color_quad = SolidColorDrawQuad::Create();
567    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false);
568    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
569
570    color_quad = SolidColorDrawQuad::Create();
571    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false);
572    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
573
574    color_quad = SolidColorDrawQuad::Create();
575    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false);
576    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
577
578    delegated_renderer_layer->SetFrameDataForRenderPasses(
579        &delegated_render_passes);
580
581    // The RenderPasses should be taken by the layer.
582    EXPECT_EQ(0u, delegated_render_passes.size());
583
584    root_layer_ = root_layer.get();
585    delegated_renderer_layer_ = delegated_renderer_layer.get();
586
587    root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
588    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
589  }
590
591  void VerifyRenderPasses(
592      const LayerTreeHostImpl::FrameData& frame,
593      size_t num_render_passes,
594      const SharedQuadState** root_delegated_shared_quad_state,
595      const SharedQuadState** contrib_delegated_shared_quad_state) {
596    ASSERT_EQ(num_render_passes, frame.render_passes.size());
597    // The contributing render pass in the DelegatedRendererLayer.
598    EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
599    EXPECT_EQ(1, frame.render_passes[0]->id.index);
600    // The root render pass.
601    EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
602    EXPECT_EQ(0, frame.render_passes.back()->id.index);
603
604    const QuadList& contrib_delegated_quad_list =
605        frame.render_passes[0]->quad_list;
606    ASSERT_EQ(2u, contrib_delegated_quad_list.size());
607
608    const QuadList& root_delegated_quad_list =
609        frame.render_passes[1]->quad_list;
610    ASSERT_EQ(5u, root_delegated_quad_list.size());
611
612    // All quads in a render pass should share the same state.
613    *contrib_delegated_shared_quad_state =
614        contrib_delegated_quad_list[0]->shared_quad_state;
615    EXPECT_EQ(*contrib_delegated_shared_quad_state,
616              contrib_delegated_quad_list[1]->shared_quad_state);
617
618    *root_delegated_shared_quad_state =
619        root_delegated_quad_list[0]->shared_quad_state;
620    EXPECT_EQ(*root_delegated_shared_quad_state,
621              root_delegated_quad_list[1]->shared_quad_state);
622    EXPECT_EQ(*root_delegated_shared_quad_state,
623              root_delegated_quad_list[2]->shared_quad_state);
624    EXPECT_EQ(*root_delegated_shared_quad_state,
625              root_delegated_quad_list[3]->shared_quad_state);
626    EXPECT_EQ(*root_delegated_shared_quad_state,
627              root_delegated_quad_list[4]->shared_quad_state);
628
629    EXPECT_NE(*contrib_delegated_shared_quad_state,
630              *root_delegated_shared_quad_state);
631  }
632
633 protected:
634  LayerImpl* root_layer_;
635  DelegatedRendererLayerImpl* delegated_renderer_layer_;
636  bool root_delegated_render_pass_is_clipped_;
637};
638
639TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
640  root_delegated_render_pass_is_clipped_ = false;
641  SetUpTest();
642
643  LayerTreeHostImpl::FrameData frame;
644  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
645
646  const SharedQuadState* root_delegated_shared_quad_state = NULL;
647  const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
648  VerifyRenderPasses(
649      frame,
650      2,
651      &root_delegated_shared_quad_state,
652      &contrib_delegated_shared_quad_state);
653
654  // When the quads don't have a clip of their own, the clip rect is set to
655  // the drawable_content_rect of the delegated renderer layer.
656  EXPECT_EQ(gfx::Rect(42, 42, 120, 120).ToString(),
657            root_delegated_shared_quad_state->clip_rect.ToString());
658
659  // Even though the quads in the root pass have no clip of their own, they
660  // inherit the clip rect from the delegated renderer layer if it does not
661  // own a surface.
662  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
663
664  gfx::Transform expected;
665  // Device scale factor is 2.
666  expected.Scale(2.0, 2.0);
667  // This is the transform from the layer's space to its target.
668  // The position (20) - the width / scale (30 / 2) = 20 - 15 = 5
669  expected.Translate(5.0, 5.0);
670  expected.Scale(2.0, 2.0);
671  expected.Translate(8.0, 8.0);
672  // The frame has size 50x50 but the layer's bounds are 30x30.
673  expected.Scale(30.0 / 50.0, 30.0 / 50.0);
674  // This is the transform within the source frame.
675  expected.Scale(1.5, 1.5);
676  expected.Translate(7.0, 7.0);
677  EXPECT_TRANSFORMATION_MATRIX_EQ(
678      expected, root_delegated_shared_quad_state->content_to_target_transform);
679
680  // The contributing render pass should not be transformed from its input.
681  EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
682            contrib_delegated_shared_quad_state->clip_rect.ToString());
683  EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
684  expected.MakeIdentity();
685  expected.Scale(0.8, 0.8);
686  expected.Translate(9.0, 9.0);
687  EXPECT_TRANSFORMATION_MATRIX_EQ(
688      expected,
689      contrib_delegated_shared_quad_state->content_to_target_transform);
690
691  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
692  host_impl_->DidDrawAllLayers(frame);
693}
694
695TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
696  root_delegated_render_pass_is_clipped_ = true;
697  SetUpTest();
698
699  LayerTreeHostImpl::FrameData frame;
700  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
701
702  const SharedQuadState* root_delegated_shared_quad_state = NULL;
703  const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
704  VerifyRenderPasses(
705      frame,
706      2,
707      &root_delegated_shared_quad_state,
708      &contrib_delegated_shared_quad_state);
709
710  // Since the quads have a clip_rect it should be modified by delegated
711  // renderer layer's draw_transform.
712  // The position of the resulting clip_rect is:
713  // (clip rect position (10) * scale to layer (30/50) + translate (8)) *
714  //     layer scale (2) + layer position (20) = 48
715  // But the layer is centered, so: 48 - (width / 2) = 48 - 30 / 2 = 33
716  // The device scale is 2, so everything gets doubled, giving 66.
717  //
718  // The size is 35x35 scaled to fit inside the layer's bounds at 30x30 from
719  // a frame at 50x50: 35 * 2 (device scale) * 30 / 50 = 42. The device scale
720  // doubles this to 84.
721  EXPECT_EQ(gfx::Rect(66, 66, 84, 84).ToString(),
722            root_delegated_shared_quad_state->clip_rect.ToString());
723
724  // The quads had a clip and it should be preserved.
725  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
726
727  gfx::Transform expected;
728  // Device scale factor is 2.
729  expected.Scale(2.0, 2.0);
730  // This is the transform from the layer's space to its target.
731  // The position (20) - the width / scale (30 / 2) = 20 - 15 = 5
732  expected.Translate(5.0, 5.0);
733  expected.Scale(2.0, 2.0);
734  expected.Translate(8.0, 8.0);
735  // The frame has size 50x50 but the layer's bounds are 30x30.
736  expected.Scale(30.0 / 50.0, 30.0 / 50.0);
737  // This is the transform within the source frame.
738  expected.Scale(1.5, 1.5);
739  expected.Translate(7.0, 7.0);
740  EXPECT_TRANSFORMATION_MATRIX_EQ(
741      expected, root_delegated_shared_quad_state->content_to_target_transform);
742
743  // The contributing render pass should not be transformed from its input.
744  EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
745            contrib_delegated_shared_quad_state->clip_rect.ToString());
746  EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
747  expected.MakeIdentity();
748  expected.Scale(0.8, 0.8);
749  expected.Translate(9.0, 9.0);
750  EXPECT_TRANSFORMATION_MATRIX_EQ(
751      expected,
752      contrib_delegated_shared_quad_state->content_to_target_transform);
753
754  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
755  host_impl_->DidDrawAllLayers(frame);
756}
757
758TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
759  root_delegated_render_pass_is_clipped_ = false;
760  SetUpTest();
761
762  delegated_renderer_layer_->SetForceRenderSurface(true);
763
764  LayerTreeHostImpl::FrameData frame;
765  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
766
767  const SharedQuadState* root_delegated_shared_quad_state = NULL;
768  const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
769  VerifyRenderPasses(
770      frame,
771      3,
772      &root_delegated_shared_quad_state,
773      &contrib_delegated_shared_quad_state);
774
775  // When the layer owns a surface, then its position and translation are not
776  // a part of its draw transform.
777  // The position of the resulting clip_rect is:
778  // (clip rect position (10) * scale to layer (30/50)) * device scale (2) = 12
779  // The size is 35x35 scaled to fit inside the layer's bounds at 30x30 from
780  // a frame at 50x50: 35 * 2 (device scale) * 30 / 50 = 42.
781  EXPECT_EQ(gfx::Rect(12, 12, 42, 42).ToString(),
782            root_delegated_shared_quad_state->clip_rect.ToString());
783
784  // Since the layer owns a surface it doesn't need to clip its quads, so
785  // unclipped quads remain unclipped.
786  EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
787
788  gfx::Transform expected;
789  // Device scale factor is 2.
790  expected.Scale(2.0, 2.0);
791  // The frame has size 50x50 but the layer's bounds are 30x30.
792  expected.Scale(30.0 / 50.0, 30.0 / 50.0);
793  // This is the transform within the source frame.
794  expected.Scale(1.5, 1.5);
795  expected.Translate(7.0, 7.0);
796  EXPECT_TRANSFORMATION_MATRIX_EQ(
797      expected, root_delegated_shared_quad_state->content_to_target_transform);
798
799  // The contributing render pass should not be transformed from its input.
800  EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
801            contrib_delegated_shared_quad_state->clip_rect.ToString());
802  EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
803  expected.MakeIdentity();
804  expected.Scale(0.8, 0.8);
805  expected.Translate(9.0, 9.0);
806  EXPECT_TRANSFORMATION_MATRIX_EQ(
807      expected,
808      contrib_delegated_shared_quad_state->content_to_target_transform);
809
810  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
811  host_impl_->DidDrawAllLayers(frame);
812}
813
814TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
815  root_delegated_render_pass_is_clipped_ = true;
816  SetUpTest();
817
818  delegated_renderer_layer_->SetForceRenderSurface(true);
819
820  LayerTreeHostImpl::FrameData frame;
821  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
822
823  const SharedQuadState* root_delegated_shared_quad_state = NULL;
824  const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
825  VerifyRenderPasses(
826      frame,
827      3,
828      &root_delegated_shared_quad_state,
829      &contrib_delegated_shared_quad_state);
830
831  // When the layer owns a surface, then its position and translation are not
832  // a part of its draw transform.
833  // The position of the resulting clip_rect is:
834  // (clip rect position (10) * scale to layer (30/50)) * device scale (2) = 12
835  // The size is 35x35 scaled to fit inside the layer's bounds at 30x30 from
836  // a frame at 50x50: 35 * 2 (device scale) * 30 / 50 = 42.
837  EXPECT_EQ(gfx::Rect(12, 12, 42, 42).ToString(),
838            root_delegated_shared_quad_state->clip_rect.ToString());
839
840  // The quads had a clip and it should be preserved.
841  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
842
843  gfx::Transform expected;
844  // Device scale factor is 2.
845  expected.Scale(2.0, 2.0);
846  // The frame has size 50x50 but the layer's bounds are 30x30.
847  expected.Scale(30.0 / 50.0, 30.0 / 50.0);
848  // This is the transform within the source frame.
849  expected.Scale(1.5, 1.5);
850  expected.Translate(7.0, 7.0);
851  EXPECT_TRANSFORMATION_MATRIX_EQ(
852      expected, root_delegated_shared_quad_state->content_to_target_transform);
853
854  // The contributing render pass should not be transformed from its input.
855  EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
856            contrib_delegated_shared_quad_state->clip_rect.ToString());
857  EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
858  expected.MakeIdentity();
859  expected.Scale(0.8, 0.8);
860  expected.Translate(9.0, 9.0);
861  EXPECT_TRANSFORMATION_MATRIX_EQ(
862      expected,
863      contrib_delegated_shared_quad_state->content_to_target_transform);
864
865  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
866  host_impl_->DidDrawAllLayers(frame);
867}
868
869class DelegatedRendererLayerImplTestClip
870    : public DelegatedRendererLayerImplTest {
871 public:
872  void SetUpTest() {
873    scoped_ptr<LayerImpl> root_layer =
874        LayerImpl::Create(host_impl_->active_tree(), 1);
875    scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
876        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
877    scoped_ptr<LayerImpl> clip_layer =
878        LayerImpl::Create(host_impl_->active_tree(), 3);
879    scoped_ptr<LayerImpl> origin_layer =
880        LayerImpl::Create(host_impl_->active_tree(), 4);
881
882    host_impl_->SetViewportSize(gfx::Size(100, 100));
883    root_layer->SetBounds(gfx::Size(100, 100));
884
885    delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
886    delegated_renderer_layer->SetBounds(gfx::Size(50, 50));
887    delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50));
888    delegated_renderer_layer->SetDrawsContent(true);
889
890    ScopedPtrVector<RenderPass> delegated_render_passes;
891
892    gfx::Size child_pass_content_bounds(7, 7);
893    gfx::Rect child_pass_rect(20, 20, 7, 7);
894    gfx::Transform child_pass_transform;
895    gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
896    bool child_pass_clipped = false;
897
898    {
899      TestRenderPass* pass = AddRenderPass(
900          &delegated_render_passes,
901          RenderPass::Id(10, 7),
902          child_pass_rect,
903          gfx::Transform());
904      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
905      AppendQuadsData data(pass->id);
906      SharedQuadState* shared_quad_state =
907          quad_sink.UseSharedQuadState(SharedQuadState::Create());
908      shared_quad_state->SetAll(
909          child_pass_transform,
910          child_pass_content_bounds,
911          child_pass_rect,
912          child_pass_clip_rect,
913          child_pass_clipped,
914          1.f);
915
916      scoped_ptr<SolidColorDrawQuad> color_quad;
917      color_quad = SolidColorDrawQuad::Create();
918      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false);
919      quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
920
921      color_quad = SolidColorDrawQuad::Create();
922      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false);
923      quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
924    }
925
926    gfx::Size root_pass_content_bounds(50, 50);
927    gfx::Rect root_pass_rect(0, 0, 50, 50);
928    gfx::Transform root_pass_transform;
929    gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
930    bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
931
932    TestRenderPass* pass = AddRenderPass(
933        &delegated_render_passes,
934        RenderPass::Id(9, 6),
935        root_pass_rect,
936        gfx::Transform());
937    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
938    AppendQuadsData data(pass->id);
939    SharedQuadState* shared_quad_state =
940        quad_sink.UseSharedQuadState(SharedQuadState::Create());
941    shared_quad_state->SetAll(root_pass_transform,
942                              root_pass_content_bounds,
943                              root_pass_rect,
944                              root_pass_clip_rect,
945                              root_pass_clipped,
946                              1.f);
947
948    scoped_ptr<RenderPassDrawQuad> render_pass_quad =
949        RenderPassDrawQuad::Create();
950    render_pass_quad->SetNew(
951        shared_quad_state,
952        gfx::Rect(5, 5, 7, 7),  // rect
953        RenderPass::Id(10, 7),  // render_pass_id
954        false,  // is_replica
955        0,  // mask_resource_id
956        child_pass_rect,  // contents_changed_since_last_frame
957        gfx::RectF(),  // mask_uv_rect
958        FilterOperations(),  // filters
959        skia::RefPtr<SkImageFilter>(),  // filter
960        FilterOperations());  // background_filters
961    quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data);
962
963    scoped_ptr<SolidColorDrawQuad> color_quad;
964    color_quad = SolidColorDrawQuad::Create();
965    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false);
966    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
967
968    color_quad = SolidColorDrawQuad::Create();
969    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false);
970    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
971
972    color_quad = SolidColorDrawQuad::Create();
973    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false);
974    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
975
976    color_quad = SolidColorDrawQuad::Create();
977    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false);
978    quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
979
980    delegated_renderer_layer->SetFrameDataForRenderPasses(
981        &delegated_render_passes);
982
983    // The RenderPasses should be taken by the layer.
984    EXPECT_EQ(0u, delegated_render_passes.size());
985
986    root_layer_ = root_layer.get();
987    delegated_renderer_layer_ = delegated_renderer_layer.get();
988
989    if (clip_delegated_renderer_layer_) {
990      gfx::Rect clip_rect(21, 27, 23, 21);
991
992      clip_layer->SetPosition(clip_rect.origin());
993      clip_layer->SetBounds(clip_rect.size());
994      clip_layer->SetContentBounds(clip_rect.size());
995      clip_layer->SetMasksToBounds(true);
996
997      origin_layer->SetPosition(
998          gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin()));
999
1000      origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1001      clip_layer->AddChild(origin_layer.Pass());
1002      root_layer->AddChild(clip_layer.Pass());
1003    } else {
1004      root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1005    }
1006
1007    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
1008  }
1009
1010 protected:
1011  LayerImpl* root_layer_;
1012  DelegatedRendererLayerImpl* delegated_renderer_layer_;
1013  bool root_delegated_render_pass_is_clipped_;
1014  bool clip_delegated_renderer_layer_;
1015};
1016
1017TEST_F(DelegatedRendererLayerImplTestClip,
1018       QuadsUnclipped_LayerUnclipped_NoSurface) {
1019  root_delegated_render_pass_is_clipped_ = false;
1020  clip_delegated_renderer_layer_ = false;
1021  SetUpTest();
1022
1023  LayerTreeHostImpl::FrameData frame;
1024  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1025
1026  ASSERT_EQ(2u, frame.render_passes.size());
1027  const QuadList& contrib_delegated_quad_list =
1028      frame.render_passes[0]->quad_list;
1029  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1030  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1031  ASSERT_EQ(5u, root_delegated_quad_list.size());
1032  const SharedQuadState* root_delegated_shared_quad_state =
1033      root_delegated_quad_list[0]->shared_quad_state;
1034
1035  // When the quads don't have a clip of their own, the clip rect is set to
1036  // the drawable_content_rect of the delegated renderer layer.
1037  EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
1038            root_delegated_shared_quad_state->clip_rect.ToString());
1039  // Quads are clipped to the delegated renderer layer.
1040  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1041
1042  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1043  host_impl_->DidDrawAllLayers(frame);
1044}
1045
1046TEST_F(DelegatedRendererLayerImplTestClip,
1047       QuadsClipped_LayerUnclipped_NoSurface) {
1048  root_delegated_render_pass_is_clipped_ = true;
1049  clip_delegated_renderer_layer_ = false;
1050  SetUpTest();
1051
1052  LayerTreeHostImpl::FrameData frame;
1053  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1054
1055  ASSERT_EQ(2u, frame.render_passes.size());
1056  const QuadList& contrib_delegated_quad_list =
1057      frame.render_passes[0]->quad_list;
1058  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1059  const QuadList& root_delegated_quad_list =
1060      frame.render_passes[1]->quad_list;
1061  ASSERT_EQ(5u, root_delegated_quad_list.size());
1062  const SharedQuadState* root_delegated_shared_quad_state =
1063      root_delegated_quad_list[0]->shared_quad_state;
1064
1065  // When the quads have a clip of their own, it is used.
1066  EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
1067            root_delegated_shared_quad_state->clip_rect.ToString());
1068  // Quads came with a clip rect.
1069  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1070
1071  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1072  host_impl_->DidDrawAllLayers(frame);
1073}
1074
1075TEST_F(DelegatedRendererLayerImplTestClip,
1076       QuadsUnclipped_LayerClipped_NoSurface) {
1077  root_delegated_render_pass_is_clipped_ = false;
1078  clip_delegated_renderer_layer_ = true;
1079  SetUpTest();
1080
1081  LayerTreeHostImpl::FrameData frame;
1082  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1083
1084  ASSERT_EQ(2u, frame.render_passes.size());
1085  const QuadList& contrib_delegated_quad_list =
1086      frame.render_passes[0]->quad_list;
1087  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1088  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1089  ASSERT_EQ(5u, root_delegated_quad_list.size());
1090  const SharedQuadState* root_delegated_shared_quad_state =
1091      root_delegated_quad_list[0]->shared_quad_state;
1092
1093  // When the quads don't have a clip of their own, the clip rect is set to
1094  // the drawable_content_rect of the delegated renderer layer. When the layer
1095  // is clipped, that should be seen in the quads' clip_rect.
1096  EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
1097            root_delegated_shared_quad_state->clip_rect.ToString());
1098  // Quads are clipped to the delegated renderer layer.
1099  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1100
1101  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1102  host_impl_->DidDrawAllLayers(frame);
1103}
1104
1105TEST_F(DelegatedRendererLayerImplTestClip,
1106       QuadsClipped_LayerClipped_NoSurface) {
1107  root_delegated_render_pass_is_clipped_ = true;
1108  clip_delegated_renderer_layer_ = true;
1109  SetUpTest();
1110
1111  LayerTreeHostImpl::FrameData frame;
1112  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1113
1114  ASSERT_EQ(2u, frame.render_passes.size());
1115  const QuadList& contrib_delegated_quad_list =
1116      frame.render_passes[0]->quad_list;
1117  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1118  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1119  ASSERT_EQ(5u, root_delegated_quad_list.size());
1120  const SharedQuadState* root_delegated_shared_quad_state =
1121      root_delegated_quad_list[0]->shared_quad_state;
1122
1123  // When the quads have a clip of their own, it is used, but it is
1124  // combined with the clip rect of the delegated renderer layer.
1125  EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(),
1126            root_delegated_shared_quad_state->clip_rect.ToString());
1127  // Quads came with a clip rect.
1128  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1129
1130  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1131  host_impl_->DidDrawAllLayers(frame);
1132}
1133
1134TEST_F(DelegatedRendererLayerImplTestClip,
1135       QuadsUnclipped_LayerUnclipped_Surface) {
1136  root_delegated_render_pass_is_clipped_ = false;
1137  clip_delegated_renderer_layer_ = false;
1138  SetUpTest();
1139
1140  delegated_renderer_layer_->SetForceRenderSurface(true);
1141
1142  LayerTreeHostImpl::FrameData frame;
1143  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1144
1145  ASSERT_EQ(3u, frame.render_passes.size());
1146  const QuadList& contrib_delegated_quad_list =
1147      frame.render_passes[0]->quad_list;
1148  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1149  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1150  ASSERT_EQ(5u, root_delegated_quad_list.size());
1151  const SharedQuadState* root_delegated_shared_quad_state =
1152      root_delegated_quad_list[0]->shared_quad_state;
1153
1154  // When the layer owns a surface, the quads don't need to be clipped
1155  // further than they already specify. If they aren't clipped, then their
1156  // clip rect is ignored, and they are not set as clipped.
1157  EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1158
1159  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1160  host_impl_->DidDrawAllLayers(frame);
1161}
1162
1163TEST_F(DelegatedRendererLayerImplTestClip,
1164       QuadsClipped_LayerUnclipped_Surface) {
1165  root_delegated_render_pass_is_clipped_ = true;
1166  clip_delegated_renderer_layer_ = false;
1167  SetUpTest();
1168
1169  delegated_renderer_layer_->SetForceRenderSurface(true);
1170
1171  LayerTreeHostImpl::FrameData frame;
1172  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1173
1174  ASSERT_EQ(3u, frame.render_passes.size());
1175  const QuadList& contrib_delegated_quad_list =
1176      frame.render_passes[0]->quad_list;
1177  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1178  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1179  ASSERT_EQ(5u, root_delegated_quad_list.size());
1180  const SharedQuadState* root_delegated_shared_quad_state =
1181      root_delegated_quad_list[0]->shared_quad_state;
1182
1183  // When the quads have a clip of their own, it is used.
1184  EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1185            root_delegated_shared_quad_state->clip_rect.ToString());
1186  // Quads came with a clip rect.
1187  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1188
1189  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1190  host_impl_->DidDrawAllLayers(frame);
1191}
1192
1193TEST_F(DelegatedRendererLayerImplTestClip,
1194       QuadsUnclipped_LayerClipped_Surface) {
1195  root_delegated_render_pass_is_clipped_ = false;
1196  clip_delegated_renderer_layer_ = true;
1197  SetUpTest();
1198
1199  delegated_renderer_layer_->SetForceRenderSurface(true);
1200
1201  LayerTreeHostImpl::FrameData frame;
1202  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1203
1204  ASSERT_EQ(3u, frame.render_passes.size());
1205  const QuadList& contrib_delegated_quad_list =
1206      frame.render_passes[0]->quad_list;
1207  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1208  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1209  ASSERT_EQ(5u, root_delegated_quad_list.size());
1210  const SharedQuadState* root_delegated_shared_quad_state =
1211      root_delegated_quad_list[0]->shared_quad_state;
1212
1213  // When the layer owns a surface, the quads don't need to be clipped
1214  // further than they already specify. If they aren't clipped, then their
1215  // clip rect is ignored, and they are not set as clipped.
1216  EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1217
1218  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1219  host_impl_->DidDrawAllLayers(frame);
1220}
1221
1222TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
1223  root_delegated_render_pass_is_clipped_ = true;
1224  clip_delegated_renderer_layer_ = true;
1225  SetUpTest();
1226
1227  delegated_renderer_layer_->SetForceRenderSurface(true);
1228
1229  LayerTreeHostImpl::FrameData frame;
1230  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
1231
1232  ASSERT_EQ(3u, frame.render_passes.size());
1233  const QuadList& contrib_delegated_quad_list =
1234      frame.render_passes[0]->quad_list;
1235  ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1236  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1237  ASSERT_EQ(5u, root_delegated_quad_list.size());
1238  const SharedQuadState* root_delegated_shared_quad_state =
1239      root_delegated_quad_list[0]->shared_quad_state;
1240
1241  // When the quads have a clip of their own, it is used, but it is
1242  // combined with the clip rect of the delegated renderer layer. If the
1243  // layer owns a surface, then it does not have a clip rect of its own.
1244  EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1245            root_delegated_shared_quad_state->clip_rect.ToString());
1246  // Quads came with a clip rect.
1247  EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1248
1249  host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
1250  host_impl_->DidDrawAllLayers(frame);
1251}
1252
1253}  // namespace
1254}  // namespace cc
1255