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/tiled_layer_impl.h"
6
7#include "cc/layers/append_quads_data.h"
8#include "cc/quads/tile_draw_quad.h"
9#include "cc/resources/layer_tiling_data.h"
10#include "cc/test/fake_impl_proxy.h"
11#include "cc/test/fake_layer_tree_host_impl.h"
12#include "cc/test/layer_test_common.h"
13#include "cc/trees/single_thread_proxy.h"
14#include "testing/gmock/include/gmock/gmock.h"
15#include "testing/gtest/include/gtest/gtest.h"
16
17namespace cc {
18namespace {
19
20class TiledLayerImplTest : public testing::Test {
21 public:
22  TiledLayerImplTest() : host_impl_(&proxy_, &shared_bitmap_manager_) {}
23
24  scoped_ptr<TiledLayerImpl> CreateLayerNoTiles(
25      const gfx::Size& tile_size,
26      const gfx::Size& layer_size,
27      LayerTilingData::BorderTexelOption border_texels) {
28    scoped_ptr<TiledLayerImpl> layer =
29        TiledLayerImpl::Create(host_impl_.active_tree(), 1);
30    scoped_ptr<LayerTilingData> tiler =
31        LayerTilingData::Create(tile_size, border_texels);
32    tiler->SetTilingSize(layer_size);
33    layer->SetTilingData(*tiler);
34    layer->set_skips_draw(false);
35    layer->draw_properties().visible_content_rect =
36        gfx::Rect(layer_size);
37    layer->draw_properties().opacity = 1;
38    layer->SetBounds(layer_size);
39    layer->SetContentBounds(layer_size);
40    layer->CreateRenderSurface();
41    layer->draw_properties().render_target = layer.get();
42    return layer.Pass();
43  }
44
45  // Create a default tiled layer with textures for all tiles and a default
46  // visibility of the entire layer size.
47  scoped_ptr<TiledLayerImpl> CreateLayer(
48      const gfx::Size& tile_size,
49      const gfx::Size& layer_size,
50      LayerTilingData::BorderTexelOption border_texels) {
51    scoped_ptr<TiledLayerImpl> layer =
52        CreateLayerNoTiles(tile_size, layer_size, border_texels);
53
54    ResourceProvider::ResourceId resource_id = 1;
55    for (int i = 0; i < layer->TilingForTesting()->num_tiles_x(); ++i) {
56      for (int j = 0; j < layer->TilingForTesting()->num_tiles_y(); ++j)
57        layer->PushTileProperties(i, j, resource_id++, false);
58    }
59
60    return layer.Pass();
61  }
62
63  void GetQuads(RenderPass* render_pass,
64                const gfx::Size& tile_size,
65                const gfx::Size& layer_size,
66                LayerTilingData::BorderTexelOption border_texel_option,
67                const gfx::Rect& visible_content_rect) {
68    scoped_ptr<TiledLayerImpl> layer =
69        CreateLayer(tile_size, layer_size, border_texel_option);
70    layer->draw_properties().visible_content_rect = visible_content_rect;
71    layer->SetBounds(layer_size);
72
73    MockOcclusionTracker<LayerImpl> occlusion_tracker;
74    AppendQuadsData data;
75    layer->AppendQuads(render_pass, occlusion_tracker, &data);
76  }
77
78 protected:
79  FakeImplProxy proxy_;
80  TestSharedBitmapManager shared_bitmap_manager_;
81  FakeLayerTreeHostImpl host_impl_;
82};
83
84TEST_F(TiledLayerImplTest, EmptyQuadList) {
85  gfx::Size tile_size(90, 90);
86  int num_tiles_x = 8;
87  int num_tiles_y = 4;
88  gfx::Size layer_size(tile_size.width() * num_tiles_x,
89                       tile_size.height() * num_tiles_y);
90
91  // Verify default layer does creates quads
92  {
93    scoped_ptr<TiledLayerImpl> layer =
94        CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
95    MockOcclusionTracker<LayerImpl> occlusion_tracker;
96    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
97
98    AppendQuadsData data;
99    EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
100    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
101    layer->DidDraw(NULL);
102    unsigned num_tiles = num_tiles_x * num_tiles_y;
103    EXPECT_EQ(render_pass->quad_list.size(), num_tiles);
104  }
105
106  // Layer with empty visible layer rect produces no quads
107  {
108    scoped_ptr<TiledLayerImpl> layer =
109        CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
110    layer->draw_properties().visible_content_rect = gfx::Rect();
111
112    MockOcclusionTracker<LayerImpl> occlusion_tracker;
113    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
114
115    EXPECT_FALSE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
116  }
117
118  // Layer with non-intersecting visible layer rect produces no quads
119  {
120    scoped_ptr<TiledLayerImpl> layer =
121        CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
122
123    gfx::Rect outside_bounds(-100, -100, 50, 50);
124    layer->draw_properties().visible_content_rect = outside_bounds;
125
126    MockOcclusionTracker<LayerImpl> occlusion_tracker;
127    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
128
129    AppendQuadsData data;
130    EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
131    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
132    layer->DidDraw(NULL);
133    EXPECT_EQ(render_pass->quad_list.size(), 0u);
134  }
135
136  // Layer with skips draw produces no quads
137  {
138    scoped_ptr<TiledLayerImpl> layer =
139        CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
140    layer->set_skips_draw(true);
141
142    MockOcclusionTracker<LayerImpl> occlusion_tracker;
143    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
144
145    AppendQuadsData data;
146    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
147    EXPECT_EQ(render_pass->quad_list.size(), 0u);
148  }
149}
150
151TEST_F(TiledLayerImplTest, Checkerboarding) {
152  gfx::Size tile_size(10, 10);
153  int num_tiles_x = 2;
154  int num_tiles_y = 2;
155  gfx::Size layer_size(tile_size.width() * num_tiles_x,
156                       tile_size.height() * num_tiles_y);
157
158  scoped_ptr<TiledLayerImpl> layer =
159      CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
160
161  // No checkerboarding
162  {
163    MockOcclusionTracker<LayerImpl> occlusion_tracker;
164    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
165
166    AppendQuadsData data;
167    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
168    EXPECT_EQ(render_pass->quad_list.size(), 4u);
169    EXPECT_EQ(0u, data.num_missing_tiles);
170
171    for (QuadList::Iterator iter = render_pass->quad_list.begin();
172         iter != render_pass->quad_list.end();
173         ++iter)
174      EXPECT_EQ(iter->material, DrawQuad::TILED_CONTENT);
175  }
176
177  for (int i = 0; i < num_tiles_x; ++i)
178    for (int j = 0; j < num_tiles_y; ++j)
179      layer->PushTileProperties(i, j, 0, false);
180
181  // All checkerboarding
182  {
183    MockOcclusionTracker<LayerImpl> occlusion_tracker;
184    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
185
186    AppendQuadsData data;
187    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
188    EXPECT_LT(0u, data.num_missing_tiles);
189    EXPECT_EQ(render_pass->quad_list.size(), 4u);
190    for (QuadList::Iterator iter = render_pass->quad_list.begin();
191         iter != render_pass->quad_list.end();
192         ++iter)
193      EXPECT_NE(iter->material, DrawQuad::TILED_CONTENT);
194  }
195}
196
197// Test with both border texels and without.
198#define WITH_AND_WITHOUT_BORDER_TEST(text_fixture_name)                        \
199  TEST_F(TiledLayerImplBorderTest, text_fixture_name##NoBorders) {             \
200    text_fixture_name(LayerTilingData::NO_BORDER_TEXELS);                      \
201  }                                                                            \
202  TEST_F(TiledLayerImplBorderTest, text_fixture_name##HasBorders) {            \
203    text_fixture_name(LayerTilingData::HAS_BORDER_TEXELS);                     \
204  }
205
206class TiledLayerImplBorderTest : public TiledLayerImplTest {
207 public:
208  void CoverageVisibleRectOnTileBoundaries(
209      LayerTilingData::BorderTexelOption borders) {
210    gfx::Size layer_size(1000, 1000);
211    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
212    GetQuads(render_pass.get(),
213             gfx::Size(100, 100),
214             layer_size,
215             borders,
216             gfx::Rect(layer_size));
217    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
218                                                 gfx::Rect(layer_size));
219  }
220
221  void CoverageVisibleRectIntersectsTiles(
222      LayerTilingData::BorderTexelOption borders) {
223    // This rect intersects the middle 3x3 of the 5x5 tiles.
224    gfx::Point top_left(65, 73);
225    gfx::Point bottom_right(182, 198);
226    gfx::Rect visible_content_rect = gfx::BoundingRect(top_left, bottom_right);
227
228    gfx::Size layer_size(250, 250);
229    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
230    GetQuads(render_pass.get(),
231             gfx::Size(50, 50),
232             gfx::Size(250, 250),
233             LayerTilingData::NO_BORDER_TEXELS,
234             visible_content_rect);
235    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
236                                                 visible_content_rect);
237  }
238
239  void CoverageVisibleRectIntersectsBounds(
240      LayerTilingData::BorderTexelOption borders) {
241    gfx::Size layer_size(220, 210);
242    gfx::Rect visible_content_rect(layer_size);
243    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
244    GetQuads(render_pass.get(),
245             gfx::Size(100, 100),
246             layer_size,
247             LayerTilingData::NO_BORDER_TEXELS,
248             visible_content_rect);
249    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
250                                                 visible_content_rect);
251  }
252};
253WITH_AND_WITHOUT_BORDER_TEST(CoverageVisibleRectOnTileBoundaries);
254
255WITH_AND_WITHOUT_BORDER_TEST(CoverageVisibleRectIntersectsTiles);
256
257WITH_AND_WITHOUT_BORDER_TEST(CoverageVisibleRectIntersectsBounds);
258
259TEST_F(TiledLayerImplTest, TextureInfoForLayerNoBorders) {
260  gfx::Size tile_size(50, 50);
261  gfx::Size layer_size(250, 250);
262  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
263  GetQuads(render_pass.get(),
264           tile_size,
265           layer_size,
266           LayerTilingData::NO_BORDER_TEXELS,
267           gfx::Rect(layer_size));
268
269  size_t i = 0;
270  for (QuadList::Iterator iter = render_pass->quad_list.begin();
271       iter != render_pass->quad_list.end();
272       ++iter) {
273    const TileDrawQuad* quad = TileDrawQuad::MaterialCast(&*iter);
274
275    EXPECT_NE(0u, quad->resource_id) << LayerTestCommon::quad_string << i;
276    EXPECT_EQ(gfx::RectF(gfx::PointF(), tile_size), quad->tex_coord_rect)
277        << LayerTestCommon::quad_string << i;
278    EXPECT_EQ(tile_size, quad->texture_size) << LayerTestCommon::quad_string
279                                             << i;
280  }
281}
282
283TEST_F(TiledLayerImplTest, GPUMemoryUsage) {
284  gfx::Size tile_size(20, 30);
285  int num_tiles_x = 12;
286  int num_tiles_y = 32;
287  gfx::Size layer_size(tile_size.width() * num_tiles_x,
288                       tile_size.height() * num_tiles_y);
289
290  scoped_ptr<TiledLayerImpl> layer = CreateLayerNoTiles(
291      tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
292
293  EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
294
295  ResourceProvider::ResourceId resource_id = 1;
296  layer->PushTileProperties(0, 1, resource_id++, false);
297  layer->PushTileProperties(2, 3, resource_id++, false);
298  layer->PushTileProperties(2, 0, resource_id++, false);
299
300  EXPECT_EQ(
301      layer->GPUMemoryUsageInBytes(),
302      static_cast<size_t>(3 * 4 * tile_size.width() * tile_size.height()));
303
304  ResourceProvider::ResourceId empty_resource(0);
305  layer->PushTileProperties(0, 1, empty_resource, false);
306  layer->PushTileProperties(2, 3, empty_resource, false);
307  layer->PushTileProperties(2, 0, empty_resource, false);
308
309  EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
310}
311
312TEST_F(TiledLayerImplTest, EmptyMask) {
313  gfx::Size tile_size(20, 20);
314  gfx::Size layer_size(0, 0);
315  scoped_ptr<TiledLayerImpl> layer =
316      CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
317
318  EXPECT_EQ(0u, layer->ContentsResourceId());
319  EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_x());
320  EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_y());
321}
322
323TEST_F(TiledLayerImplTest, Occlusion) {
324  gfx::Size tile_size(100, 100);
325  gfx::Size layer_bounds(1000, 1000);
326  gfx::Size viewport_size(1000, 1000);
327
328  LayerTestCommon::LayerImplTest impl;
329
330  TiledLayerImpl* tiled_layer = impl.AddChildToRoot<TiledLayerImpl>();
331  tiled_layer->SetBounds(layer_bounds);
332  tiled_layer->SetContentBounds(layer_bounds);
333  tiled_layer->SetDrawsContent(true);
334  tiled_layer->set_skips_draw(false);
335
336  scoped_ptr<LayerTilingData> tiler =
337      LayerTilingData::Create(tile_size, LayerTilingData::NO_BORDER_TEXELS);
338  tiler->SetTilingSize(layer_bounds);
339  tiled_layer->SetTilingData(*tiler);
340
341  ResourceProvider::ResourceId resource_id = 1;
342  for (int i = 0; i < tiled_layer->TilingForTesting()->num_tiles_x(); ++i) {
343    for (int j = 0; j < tiled_layer->TilingForTesting()->num_tiles_y(); ++j)
344      tiled_layer->PushTileProperties(i, j, resource_id++, false);
345  }
346
347  impl.CalcDrawProps(viewport_size);
348
349  {
350    SCOPED_TRACE("No occlusion");
351    gfx::Rect occluded;
352    impl.AppendQuadsWithOcclusion(tiled_layer, occluded);
353
354    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
355                                                 gfx::Rect(layer_bounds));
356    EXPECT_EQ(100u, impl.quad_list().size());
357  }
358
359  {
360    SCOPED_TRACE("Full occlusion");
361    gfx::Rect occluded(tiled_layer->visible_content_rect());
362    impl.AppendQuadsWithOcclusion(tiled_layer, occluded);
363
364    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
365    EXPECT_EQ(impl.quad_list().size(), 0u);
366  }
367
368  {
369    SCOPED_TRACE("Partial occlusion");
370    gfx::Rect occluded(150, 0, 200, 1000);
371    impl.AppendQuadsWithOcclusion(tiled_layer, occluded);
372
373    size_t partially_occluded_count = 0;
374    LayerTestCommon::VerifyQuadsAreOccluded(
375        impl.quad_list(), occluded, &partially_occluded_count);
376    // The layer outputs one quad, which is partially occluded.
377    EXPECT_EQ(100u - 10u, impl.quad_list().size());
378    EXPECT_EQ(10u + 10u, partially_occluded_count);
379  }
380}
381
382}  // namespace
383}  // namespace cc
384