1 // Copyright 2013 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/append_quads_data.h"
6 #include "cc/layers/ui_resource_layer_impl.h"
7 #include "cc/quads/draw_quad.h"
8 #include "cc/resources/ui_resource_bitmap.h"
9 #include "cc/resources/ui_resource_client.h"
10 #include "cc/test/fake_impl_proxy.h"
11 #include "cc/test/fake_layer_tree_host_impl.h"
12 #include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
13 #include "cc/test/layer_test_common.h"
14 #include "cc/test/test_shared_bitmap_manager.h"
15 #include "cc/trees/single_thread_proxy.h"
16 #include "testing/gmock/include/gmock/gmock.h"
17 #include "testing/gtest/include/gtest/gtest.h"
18 #include "ui/gfx/geometry/size_conversions.h"
19 #include "ui/gfx/transform.h"
24 scoped_ptr
<UIResourceLayerImpl
> GenerateUIResourceLayer(
25 FakeUIResourceLayerTreeHostImpl
* host_impl
,
26 const gfx::Size
& bitmap_size
,
27 const gfx::Size
& layer_size
,
30 gfx::Rect
visible_content_rect(layer_size
);
31 scoped_ptr
<UIResourceLayerImpl
> layer
=
32 UIResourceLayerImpl::Create(host_impl
->active_tree(), 1);
33 layer
->draw_properties().visible_content_rect
= visible_content_rect
;
34 layer
->SetBounds(layer_size
);
35 layer
->SetContentBounds(layer_size
);
36 layer
->CreateRenderSurface();
37 layer
->draw_properties().render_target
= layer
.get();
39 UIResourceBitmap
bitmap(bitmap_size
, opaque
);
41 host_impl
->CreateUIResource(uid
, bitmap
);
42 layer
->SetUIResourceId(uid
);
47 void QuadSizeTest(scoped_ptr
<UIResourceLayerImpl
> layer
,
48 size_t expected_quad_size
) {
49 scoped_ptr
<RenderPass
> render_pass
= RenderPass::Create();
52 layer
->AppendQuads(render_pass
.get(), Occlusion(), &data
);
55 const QuadList
& quads
= render_pass
->quad_list
;
56 EXPECT_EQ(expected_quad_size
, quads
.size());
59 TEST(UIResourceLayerImplTest
, VerifyDrawQuads
) {
61 TestSharedBitmapManager shared_bitmap_manager
;
62 FakeUIResourceLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
);
63 // Make sure we're appending quads when there are valid values.
64 gfx::Size
bitmap_size(100, 100);
65 gfx::Size
layer_size(100, 100);;
66 size_t expected_quad_size
= 1;
69 scoped_ptr
<UIResourceLayerImpl
> layer
= GenerateUIResourceLayer(&host_impl
,
74 QuadSizeTest(layer
.Pass(), expected_quad_size
);
76 // Make sure we're not appending quads when there are invalid values.
77 expected_quad_size
= 0;
79 layer
= GenerateUIResourceLayer(&host_impl
,
84 QuadSizeTest(layer
.Pass(), expected_quad_size
);
87 void OpaqueBoundsTest(scoped_ptr
<UIResourceLayerImpl
> layer
,
88 const gfx::Rect
& expected_opaque_bounds
) {
89 scoped_ptr
<RenderPass
> render_pass
= RenderPass::Create();
92 layer
->AppendQuads(render_pass
.get(), Occlusion(), &data
);
95 const QuadList
& quads
= render_pass
->quad_list
;
96 EXPECT_GE(quads
.size(), (size_t)0);
97 gfx::Rect opaque_rect
= quads
.front()->opaque_rect
;
98 EXPECT_EQ(expected_opaque_bounds
, opaque_rect
);
101 TEST(UIResourceLayerImplTest
, VerifySetOpaqueOnSkBitmap
) {
103 TestSharedBitmapManager shared_bitmap_manager
;
104 FakeUIResourceLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
);
106 gfx::Size
bitmap_size(100, 100);
107 gfx::Size
layer_size(100, 100);;
109 UIResourceId uid
= 1;
110 scoped_ptr
<UIResourceLayerImpl
> layer
= GenerateUIResourceLayer(&host_impl
,
115 gfx::Rect expected_opaque_bounds
;
116 OpaqueBoundsTest(layer
.Pass(), expected_opaque_bounds
);
119 layer
= GenerateUIResourceLayer(&host_impl
,
124 expected_opaque_bounds
= gfx::Rect(gfx::ToCeiledSize(layer
->bounds()));
125 OpaqueBoundsTest(layer
.Pass(), expected_opaque_bounds
);
128 TEST(UIResourceLayerImplTest
, VerifySetOpaqueOnLayer
) {
130 TestSharedBitmapManager shared_bitmap_manager
;
131 FakeUIResourceLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
);
133 gfx::Size
bitmap_size(100, 100);
134 gfx::Size
layer_size(100, 100);
135 bool skbitmap_opaque
= false;
136 UIResourceId uid
= 1;
137 scoped_ptr
<UIResourceLayerImpl
> layer
= GenerateUIResourceLayer(
138 &host_impl
, bitmap_size
, layer_size
, skbitmap_opaque
, uid
);
139 layer
->SetContentsOpaque(false);
140 gfx::Rect expected_opaque_bounds
;
141 OpaqueBoundsTest(layer
.Pass(), expected_opaque_bounds
);
143 layer
= GenerateUIResourceLayer(
144 &host_impl
, bitmap_size
, layer_size
, skbitmap_opaque
, uid
);
145 layer
->SetContentsOpaque(true);
146 expected_opaque_bounds
= gfx::Rect(gfx::ToCeiledSize(layer
->bounds()));
147 OpaqueBoundsTest(layer
.Pass(), expected_opaque_bounds
);
150 TEST(UIResourceLayerImplTest
, Occlusion
) {
151 gfx::Size
layer_size(1000, 1000);
152 gfx::Size
viewport_size(1000, 1000);
154 LayerTestCommon::LayerImplTest impl
;
157 sk_bitmap
.allocN32Pixels(10, 10);
158 sk_bitmap
.setImmutable();
159 UIResourceId uid
= 5;
160 UIResourceBitmap
bitmap(sk_bitmap
);
161 impl
.host_impl()->CreateUIResource(uid
, bitmap
);
163 UIResourceLayerImpl
* ui_resource_layer_impl
=
164 impl
.AddChildToRoot
<UIResourceLayerImpl
>();
165 ui_resource_layer_impl
->SetBounds(layer_size
);
166 ui_resource_layer_impl
->SetContentBounds(layer_size
);
167 ui_resource_layer_impl
->SetDrawsContent(true);
168 ui_resource_layer_impl
->SetUIResourceId(uid
);
170 impl
.CalcDrawProps(viewport_size
);
173 SCOPED_TRACE("No occlusion");
175 impl
.AppendQuadsWithOcclusion(ui_resource_layer_impl
, occluded
);
177 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl
.quad_list(),
178 gfx::Rect(layer_size
));
179 EXPECT_EQ(1u, impl
.quad_list().size());
183 SCOPED_TRACE("Full occlusion");
184 gfx::Rect
occluded(ui_resource_layer_impl
->visible_content_rect());
185 impl
.AppendQuadsWithOcclusion(ui_resource_layer_impl
, occluded
);
187 LayerTestCommon::VerifyQuadsExactlyCoverRect(impl
.quad_list(), gfx::Rect());
188 EXPECT_EQ(impl
.quad_list().size(), 0u);
192 SCOPED_TRACE("Partial occlusion");
193 gfx::Rect
occluded(200, 0, 800, 1000);
194 impl
.AppendQuadsWithOcclusion(ui_resource_layer_impl
, occluded
);
196 size_t partially_occluded_count
= 0;
197 LayerTestCommon::VerifyQuadsAreOccluded(
198 impl
.quad_list(), occluded
, &partially_occluded_count
);
199 // The layer outputs one quad, which is partially occluded.
200 EXPECT_EQ(1u, impl
.quad_list().size());
201 EXPECT_EQ(1u, partially_occluded_count
);