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/layer_iterator.h"
6
7#include <vector>
8
9#include "cc/layers/layer.h"
10#include "cc/test/fake_layer_tree_host.h"
11#include "cc/trees/layer_tree_host_common.h"
12#include "testing/gmock/include/gmock/gmock.h"
13#include "testing/gtest/include/gtest/gtest.h"
14#include "ui/gfx/transform.h"
15
16using ::testing::Mock;
17using ::testing::_;
18using ::testing::AtLeast;
19using ::testing::AnyNumber;
20
21namespace cc {
22namespace {
23
24class TestLayer : public Layer {
25 public:
26  static scoped_refptr<TestLayer> Create() {
27    return make_scoped_refptr(new TestLayer());
28  }
29
30  int count_representing_target_surface_;
31  int count_representing_contributing_surface_;
32  int count_representing_itself_;
33
34  virtual bool DrawsContent() const OVERRIDE { return draws_content_; }
35  void set_draws_content(bool draws_content) { draws_content_ = draws_content; }
36
37 private:
38  TestLayer() : Layer(), draws_content_(true) {
39    SetBounds(gfx::Size(100, 100));
40    SetPosition(gfx::Point());
41  }
42  virtual ~TestLayer() {}
43
44  bool draws_content_;
45};
46
47#define EXPECT_COUNT(layer, target, contrib, itself)                           \
48  EXPECT_EQ(target, layer->count_representing_target_surface_);                \
49  EXPECT_EQ(contrib, layer->count_representing_contributing_surface_);         \
50  EXPECT_EQ(itself, layer->count_representing_itself_);
51
52typedef LayerIterator<Layer> FrontToBack;
53
54void ResetCounts(RenderSurfaceLayerList* render_surface_layer_list) {
55  for (unsigned surface_index = 0;
56       surface_index < render_surface_layer_list->size();
57       ++surface_index) {
58    TestLayer* render_surface_layer = static_cast<TestLayer*>(
59        render_surface_layer_list->at(surface_index));
60    RenderSurface* render_surface = render_surface_layer->render_surface();
61
62    render_surface_layer->count_representing_target_surface_ = -1;
63    render_surface_layer->count_representing_contributing_surface_ = -1;
64    render_surface_layer->count_representing_itself_ = -1;
65
66    for (unsigned layer_index = 0;
67         layer_index < render_surface->layer_list().size();
68         ++layer_index) {
69      TestLayer* layer = static_cast<TestLayer*>(
70          render_surface->layer_list().at(layer_index).get());
71
72      layer->count_representing_target_surface_ = -1;
73      layer->count_representing_contributing_surface_ = -1;
74      layer->count_representing_itself_ = -1;
75    }
76  }
77}
78
79void IterateFrontToBack(
80    RenderSurfaceLayerList* render_surface_layer_list) {
81  ResetCounts(render_surface_layer_list);
82  int count = 0;
83  for (FrontToBack it = FrontToBack::Begin(render_surface_layer_list);
84       it != FrontToBack::End(render_surface_layer_list);
85       ++it, ++count) {
86    TestLayer* layer = static_cast<TestLayer*>(*it);
87    if (it.represents_target_render_surface())
88      layer->count_representing_target_surface_ = count;
89    if (it.represents_contributing_render_surface())
90      layer->count_representing_contributing_surface_ = count;
91    if (it.represents_itself())
92      layer->count_representing_itself_ = count;
93  }
94}
95
96TEST(LayerIteratorTest, EmptyTree) {
97  RenderSurfaceLayerList render_surface_layer_list;
98
99  IterateFrontToBack(&render_surface_layer_list);
100}
101
102TEST(LayerIteratorTest, SimpleTree) {
103  scoped_refptr<TestLayer> root_layer = TestLayer::Create();
104  scoped_refptr<TestLayer> first = TestLayer::Create();
105  scoped_refptr<TestLayer> second = TestLayer::Create();
106  scoped_refptr<TestLayer> third = TestLayer::Create();
107  scoped_refptr<TestLayer> fourth = TestLayer::Create();
108
109  root_layer->AddChild(first);
110  root_layer->AddChild(second);
111  root_layer->AddChild(third);
112  root_layer->AddChild(fourth);
113
114  FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
115  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
116  host->SetRootLayer(root_layer);
117
118  RenderSurfaceLayerList render_surface_layer_list;
119  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
120      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
121  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
122
123  IterateFrontToBack(&render_surface_layer_list);
124  EXPECT_COUNT(root_layer, 5, -1, 4);
125  EXPECT_COUNT(first, -1, -1, 3);
126  EXPECT_COUNT(second, -1, -1, 2);
127  EXPECT_COUNT(third, -1, -1, 1);
128  EXPECT_COUNT(fourth, -1, -1, 0);
129}
130
131TEST(LayerIteratorTest, ComplexTree) {
132  scoped_refptr<TestLayer> root_layer = TestLayer::Create();
133  scoped_refptr<TestLayer> root1 = TestLayer::Create();
134  scoped_refptr<TestLayer> root2 = TestLayer::Create();
135  scoped_refptr<TestLayer> root3 = TestLayer::Create();
136  scoped_refptr<TestLayer> root21 = TestLayer::Create();
137  scoped_refptr<TestLayer> root22 = TestLayer::Create();
138  scoped_refptr<TestLayer> root23 = TestLayer::Create();
139  scoped_refptr<TestLayer> root221 = TestLayer::Create();
140  scoped_refptr<TestLayer> root231 = TestLayer::Create();
141
142  root_layer->AddChild(root1);
143  root_layer->AddChild(root2);
144  root_layer->AddChild(root3);
145  root2->AddChild(root21);
146  root2->AddChild(root22);
147  root2->AddChild(root23);
148  root22->AddChild(root221);
149  root23->AddChild(root231);
150
151  FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
152  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
153  host->SetRootLayer(root_layer);
154
155  RenderSurfaceLayerList render_surface_layer_list;
156  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
157      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
158  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
159
160  IterateFrontToBack(&render_surface_layer_list);
161  EXPECT_COUNT(root_layer, 9, -1, 8);
162  EXPECT_COUNT(root1, -1, -1, 7);
163  EXPECT_COUNT(root2, -1, -1, 6);
164  EXPECT_COUNT(root21, -1, -1, 5);
165  EXPECT_COUNT(root22, -1, -1, 4);
166  EXPECT_COUNT(root221, -1, -1, 3);
167  EXPECT_COUNT(root23, -1, -1, 2);
168  EXPECT_COUNT(root231, -1, -1, 1);
169  EXPECT_COUNT(root3, -1, -1, 0);
170}
171
172TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
173  scoped_refptr<TestLayer> root_layer = TestLayer::Create();
174  scoped_refptr<TestLayer> root1 = TestLayer::Create();
175  scoped_refptr<TestLayer> root2 = TestLayer::Create();
176  scoped_refptr<TestLayer> root3 = TestLayer::Create();
177  scoped_refptr<TestLayer> root21 = TestLayer::Create();
178  scoped_refptr<TestLayer> root22 = TestLayer::Create();
179  scoped_refptr<TestLayer> root23 = TestLayer::Create();
180  scoped_refptr<TestLayer> root221 = TestLayer::Create();
181  scoped_refptr<TestLayer> root231 = TestLayer::Create();
182
183  root_layer->AddChild(root1);
184  root_layer->AddChild(root2);
185  root_layer->AddChild(root3);
186  root2->set_draws_content(false);
187  root2->SetOpacity(0.5f);
188  root2->SetForceRenderSurface(true);  // Force the layer to own a new surface.
189  root2->AddChild(root21);
190  root2->AddChild(root22);
191  root2->AddChild(root23);
192  root22->SetOpacity(0.5f);
193  root22->AddChild(root221);
194  root23->SetOpacity(0.5f);
195  root23->AddChild(root231);
196
197  FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
198  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
199  host->SetRootLayer(root_layer);
200
201  RenderSurfaceLayerList render_surface_layer_list;
202  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
203      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
204  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
205
206  IterateFrontToBack(&render_surface_layer_list);
207  EXPECT_COUNT(root_layer, 14, -1, 13);
208  EXPECT_COUNT(root1, -1, -1, 12);
209  EXPECT_COUNT(root2, 10, 11, -1);
210  EXPECT_COUNT(root21, -1, -1, 9);
211  EXPECT_COUNT(root22, 7, 8, 6);
212  EXPECT_COUNT(root221, -1, -1, 5);
213  EXPECT_COUNT(root23, 3, 4, 2);
214  EXPECT_COUNT(root231, -1, -1, 1);
215  EXPECT_COUNT(root3, -1, -1, 0);
216}
217
218}  // namespace
219}  // namespace cc
220