1 // Copyright 2011 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/layer_impl.h"
7 #include "cc/layers/painted_scrollbar_layer_impl.h"
8 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
9 #include "cc/output/filter_operation.h"
10 #include "cc/output/filter_operations.h"
11 #include "cc/test/fake_impl_proxy.h"
12 #include "cc/test/fake_layer_tree_host_impl.h"
13 #include "cc/test/fake_output_surface.h"
14 #include "cc/test/geometry_test_utils.h"
15 #include "cc/test/test_shared_bitmap_manager.h"
16 #include "cc/test/test_task_graph_runner.h"
17 #include "cc/trees/layer_tree_impl.h"
18 #include "cc/trees/single_thread_proxy.h"
19 #include "cc/trees/tree_synchronizer.h"
20 #include "testing/gmock/include/gmock/gmock.h"
21 #include "testing/gtest/include/gtest/gtest.h"
22 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
27 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \
28 root->ResetAllChangeTrackingForSubtree(); \
30 EXPECT_TRUE(root->needs_push_properties()); \
31 EXPECT_FALSE(child->needs_push_properties()); \
32 EXPECT_FALSE(grand_child->needs_push_properties()); \
33 EXPECT_TRUE(root->LayerPropertyChanged()); \
34 EXPECT_TRUE(child->LayerPropertyChanged()); \
35 EXPECT_TRUE(grand_child->LayerPropertyChanged());
37 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \
38 root->ResetAllChangeTrackingForSubtree(); \
40 EXPECT_FALSE(root->needs_push_properties()); \
41 EXPECT_FALSE(child->needs_push_properties()); \
42 EXPECT_FALSE(grand_child->needs_push_properties()); \
43 EXPECT_FALSE(root->LayerPropertyChanged()); \
44 EXPECT_FALSE(child->LayerPropertyChanged()); \
45 EXPECT_FALSE(grand_child->LayerPropertyChanged());
47 #define EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( \
49 root->ResetAllChangeTrackingForSubtree(); \
51 EXPECT_TRUE(root->needs_push_properties()); \
52 EXPECT_FALSE(child->needs_push_properties()); \
53 EXPECT_FALSE(grand_child->needs_push_properties()); \
54 EXPECT_FALSE(root->LayerPropertyChanged()); \
55 EXPECT_FALSE(child->LayerPropertyChanged()); \
56 EXPECT_FALSE(grand_child->LayerPropertyChanged());
58 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \
59 root->ResetAllChangeTrackingForSubtree(); \
61 EXPECT_TRUE(root->needs_push_properties()); \
62 EXPECT_FALSE(child->needs_push_properties()); \
63 EXPECT_FALSE(grand_child->needs_push_properties()); \
64 EXPECT_TRUE(root->LayerPropertyChanged()); \
65 EXPECT_FALSE(child->LayerPropertyChanged()); \
66 EXPECT_FALSE(grand_child->LayerPropertyChanged());
68 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
69 root->ResetAllChangeTrackingForSubtree(); \
70 host_impl.ForcePrepareToDraw(); \
71 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \
73 EXPECT_TRUE(host_impl.active_tree()->needs_update_draw_properties());
75 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
76 root->ResetAllChangeTrackingForSubtree(); \
77 host_impl.ForcePrepareToDraw(); \
78 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \
80 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());
82 TEST(LayerImplTest
, VerifyLayerChangesAreTrackedProperly
) {
84 // This test checks that layerPropertyChanged() has the correct behavior.
87 // The constructor on this will fake that we are on the correct thread.
88 // Create a simple LayerImpl tree:
90 TestSharedBitmapManager shared_bitmap_manager
;
91 TestTaskGraphRunner task_graph_runner
;
92 scoped_ptr
<OutputSurface
> output_surface
= FakeOutputSurface::Create3d();
93 FakeLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
,
95 EXPECT_TRUE(host_impl
.InitializeRenderer(output_surface
.get()));
96 scoped_ptr
<LayerImpl
> root_clip
=
97 LayerImpl::Create(host_impl
.active_tree(), 1);
98 scoped_ptr
<LayerImpl
> root_ptr
=
99 LayerImpl::Create(host_impl
.active_tree(), 2);
100 LayerImpl
* root
= root_ptr
.get();
101 root_clip
->AddChild(root_ptr
.Pass());
102 scoped_ptr
<LayerImpl
> scroll_parent
=
103 LayerImpl::Create(host_impl
.active_tree(), 3);
104 LayerImpl
* scroll_child
= LayerImpl::Create(host_impl
.active_tree(), 4).get();
105 std::set
<LayerImpl
*>* scroll_children
= new std::set
<LayerImpl
*>();
106 scroll_children
->insert(scroll_child
);
107 scroll_children
->insert(root
);
108 root
->SetHasRenderSurface(true);
110 scoped_ptr
<LayerImpl
> clip_parent
=
111 LayerImpl::Create(host_impl
.active_tree(), 5);
112 LayerImpl
* clip_child
= LayerImpl::Create(host_impl
.active_tree(), 6).get();
113 std::set
<LayerImpl
*>* clip_children
= new std::set
<LayerImpl
*>();
114 clip_children
->insert(clip_child
);
115 clip_children
->insert(root
);
117 root
->AddChild(LayerImpl::Create(host_impl
.active_tree(), 7));
118 LayerImpl
* child
= root
->children()[0];
119 child
->AddChild(LayerImpl::Create(host_impl
.active_tree(), 8));
120 LayerImpl
* grand_child
= child
->children()[0];
122 root
->SetScrollClipLayer(root_clip
->id());
124 // Adding children is an internal operation and should not mark layers as
126 EXPECT_FALSE(root
->LayerPropertyChanged());
127 EXPECT_FALSE(child
->LayerPropertyChanged());
128 EXPECT_FALSE(grand_child
->LayerPropertyChanged());
130 gfx::PointF arbitrary_point_f
= gfx::PointF(0.125f
, 0.25f
);
131 gfx::Point3F arbitrary_point_3f
= gfx::Point3F(0.125f
, 0.25f
, 0.f
);
132 float arbitrary_number
= 0.352f
;
133 gfx::Size arbitrary_size
= gfx::Size(111, 222);
134 gfx::Point arbitrary_point
= gfx::Point(333, 444);
135 gfx::Vector2d arbitrary_vector2d
= gfx::Vector2d(111, 222);
136 gfx::Rect arbitrary_rect
= gfx::Rect(arbitrary_point
, arbitrary_size
);
137 gfx::RectF arbitrary_rect_f
=
138 gfx::RectF(arbitrary_point_f
, gfx::SizeF(1.234f
, 5.678f
));
139 SkColor arbitrary_color
= SkColorSetRGB(10, 20, 30);
140 gfx::Transform arbitrary_transform
;
141 arbitrary_transform
.Scale3d(0.1f
, 0.2f
, 0.3f
);
142 FilterOperations arbitrary_filters
;
143 arbitrary_filters
.Append(FilterOperation::CreateOpacityFilter(0.5f
));
144 SkXfermode::Mode arbitrary_blend_mode
= SkXfermode::kMultiply_Mode
;
146 // These properties are internal, and should not be considered "change" when
148 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
149 root
->SetUpdateRect(arbitrary_rect
));
150 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root
->SetBounds(arbitrary_size
));
152 // Changing these properties affects the entire subtree of layers.
153 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
154 root
->SetTransformOrigin(arbitrary_point_3f
));
155 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetFilters(arbitrary_filters
));
156 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetFilters(FilterOperations()));
157 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
158 root
->SetMaskLayer(LayerImpl::Create(host_impl
.active_tree(), 9)));
159 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetMasksToBounds(true));
160 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetContentsOpaque(true));
161 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
162 root
->SetReplicaLayer(LayerImpl::Create(host_impl
.active_tree(), 10)));
163 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetPosition(arbitrary_point_f
));
164 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetShouldFlattenTransform(false));
165 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->Set3dSortingContextId(1));
166 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
167 root
->SetDoubleSided(false)); // constructor initializes it to "true".
168 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->ScrollBy(arbitrary_vector2d
));
169 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetScrollDelta(gfx::Vector2d()));
170 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->PushScrollOffsetFromMainThread(
171 gfx::ScrollOffset(arbitrary_vector2d
)));
172 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetHideLayerAndSubtree(true));
173 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetOpacity(arbitrary_number
));
174 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetBlendMode(arbitrary_blend_mode
));
175 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetTransform(arbitrary_transform
));
177 // Changing these properties only affects the layer itself.
178 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root
->SetDrawsContent(true));
179 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
180 root
->SetBackgroundColor(arbitrary_color
));
181 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
182 root
->SetBackgroundFilters(arbitrary_filters
));
184 // Special case: check that SetBounds changes behavior depending on
186 root
->SetMasksToBounds(false);
187 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root
->SetBounds(gfx::Size(135, 246)));
188 root
->SetMasksToBounds(true);
189 // Should be a different size than previous call, to ensure it marks tree
191 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root
->SetBounds(arbitrary_size
));
193 // Changing this property does not cause the layer to be marked as changed
194 // but does cause the layer to need to push properties.
195 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
196 root
->SetIsRootForIsolatedGroup(true));
198 // Changing these properties should cause the layer to need to push properties
199 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
200 root
->SetScrollParent(scroll_parent
.get()));
201 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
202 root
->SetScrollChildren(scroll_children
));
203 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
204 root
->SetClipParent(clip_parent
.get()));
205 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
206 root
->SetClipChildren(clip_children
));
207 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
208 root
->SetNumDescendantsThatDrawContent(10));
210 // After setting all these properties already, setting to the exact same
211 // values again should not cause any change.
212 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
213 root
->SetTransformOrigin(arbitrary_point_3f
));
214 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->SetMasksToBounds(true));
215 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
216 root
->SetPosition(arbitrary_point_f
));
217 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
218 root
->SetShouldFlattenTransform(false));
219 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->Set3dSortingContextId(1));
220 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
221 root
->SetTransform(arbitrary_transform
));
222 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
223 root
->SetDoubleSided(false)); // constructor initializes it to "true".
224 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
225 root
->SetScrollDelta(gfx::Vector2d()));
226 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
227 root
->PushScrollOffsetFromMainThread(
228 gfx::ScrollOffset(arbitrary_vector2d
)));
229 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->SetContentsOpaque(true));
230 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->SetOpacity(arbitrary_number
));
231 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
232 root
->SetBlendMode(arbitrary_blend_mode
));
233 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
234 root
->SetIsRootForIsolatedGroup(true));
235 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->SetDrawsContent(true));
236 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root
->SetBounds(arbitrary_size
));
237 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
238 root
->SetScrollParent(scroll_parent
.get()));
239 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
240 root
->SetScrollChildren(scroll_children
));
241 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
242 root
->SetClipParent(clip_parent
.get()));
243 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
244 root
->SetClipChildren(clip_children
));
247 TEST(LayerImplTest
, VerifyNeedsUpdateDrawProperties
) {
249 TestSharedBitmapManager shared_bitmap_manager
;
250 TestTaskGraphRunner task_graph_runner
;
251 scoped_ptr
<OutputSurface
> output_surface
= FakeOutputSurface::Create3d();
252 FakeLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
,
254 EXPECT_TRUE(host_impl
.InitializeRenderer(output_surface
.get()));
255 host_impl
.active_tree()->SetRootLayer(
256 LayerImpl::Create(host_impl
.active_tree(), 1));
257 LayerImpl
* root
= host_impl
.active_tree()->root_layer();
258 root
->SetHasRenderSurface(true);
259 scoped_ptr
<LayerImpl
> layer_ptr
=
260 LayerImpl::Create(host_impl
.active_tree(), 2);
261 LayerImpl
* layer
= layer_ptr
.get();
262 root
->AddChild(layer_ptr
.Pass());
263 layer
->SetScrollClipLayer(root
->id());
264 DCHECK(host_impl
.CanDraw());
266 gfx::PointF arbitrary_point_f
= gfx::PointF(0.125f
, 0.25f
);
267 float arbitrary_number
= 0.352f
;
268 gfx::Size arbitrary_size
= gfx::Size(111, 222);
269 gfx::Point arbitrary_point
= gfx::Point(333, 444);
270 gfx::Vector2d arbitrary_vector2d
= gfx::Vector2d(111, 222);
271 gfx::Size large_size
= gfx::Size(1000, 1000);
272 gfx::Rect arbitrary_rect
= gfx::Rect(arbitrary_point
, arbitrary_size
);
273 gfx::RectF arbitrary_rect_f
=
274 gfx::RectF(arbitrary_point_f
, gfx::SizeF(1.234f
, 5.678f
));
275 SkColor arbitrary_color
= SkColorSetRGB(10, 20, 30);
276 gfx::Transform arbitrary_transform
;
277 arbitrary_transform
.Scale3d(0.1f
, 0.2f
, 0.3f
);
278 FilterOperations arbitrary_filters
;
279 arbitrary_filters
.Append(FilterOperation::CreateOpacityFilter(0.5f
));
280 SkXfermode::Mode arbitrary_blend_mode
= SkXfermode::kMultiply_Mode
;
282 // Render surface functions.
283 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetHasRenderSurface(true));
284 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetHasRenderSurface(true));
285 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetHasRenderSurface(false));
286 // Create a render surface, because we must have a render surface if we have
288 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetHasRenderSurface(true));
290 // Related filter functions.
291 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetFilters(arbitrary_filters
));
292 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetFilters(arbitrary_filters
));
293 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetFilters(FilterOperations()));
294 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetFilters(arbitrary_filters
));
296 // Related scrolling functions.
297 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetBounds(large_size
));
298 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetBounds(large_size
));
299 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->ScrollBy(arbitrary_vector2d
));
300 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->ScrollBy(gfx::Vector2d()));
301 layer
->SetScrollDelta(gfx::Vector2d(0, 0));
302 host_impl
.ForcePrepareToDraw();
303 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
304 layer
->SetScrollDelta(arbitrary_vector2d
));
305 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
306 layer
->SetScrollDelta(arbitrary_vector2d
));
307 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->PushScrollOffsetFromMainThread(
308 gfx::ScrollOffset(arbitrary_vector2d
)));
309 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->PushScrollOffsetFromMainThread(
310 gfx::ScrollOffset(arbitrary_vector2d
)));
312 // Unrelated functions, always set to new values, always set needs update.
313 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
314 layer
->SetMaskLayer(LayerImpl::Create(host_impl
.active_tree(), 4)));
315 host_impl
.active_tree()->BuildPropertyTreesForTesting();
316 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetMasksToBounds(true));
317 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetContentsOpaque(true));
318 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
319 layer
->SetReplicaLayer(LayerImpl::Create(host_impl
.active_tree(), 5)));
320 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetPosition(arbitrary_point_f
));
321 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetShouldFlattenTransform(false));
322 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->Set3dSortingContextId(1));
324 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
325 layer
->SetDoubleSided(false)); // constructor initializes it to "true".
326 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetDrawsContent(true));
327 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
328 layer
->SetBackgroundColor(arbitrary_color
));
329 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
330 layer
->SetBackgroundFilters(arbitrary_filters
));
331 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetOpacity(arbitrary_number
));
332 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
333 layer
->SetBlendMode(arbitrary_blend_mode
));
334 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetTransform(arbitrary_transform
));
335 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetBounds(arbitrary_size
));
337 // Unrelated functions, set to the same values, no needs update.
338 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
339 layer
->SetIsRootForIsolatedGroup(true));
340 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetFilters(arbitrary_filters
));
341 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetMasksToBounds(true));
342 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetContentsOpaque(true));
343 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetPosition(arbitrary_point_f
));
344 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->Set3dSortingContextId(1));
345 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
346 layer
->SetDoubleSided(false)); // constructor initializes it to "true".
347 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetDrawsContent(true));
348 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
349 layer
->SetBackgroundColor(arbitrary_color
));
350 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
351 layer
->SetBackgroundFilters(arbitrary_filters
));
352 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetOpacity(arbitrary_number
));
353 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
354 layer
->SetBlendMode(arbitrary_blend_mode
));
355 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
356 layer
->SetIsRootForIsolatedGroup(true));
357 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
358 layer
->SetTransform(arbitrary_transform
));
359 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer
->SetBounds(arbitrary_size
));
362 TEST(LayerImplTest
, SafeOpaqueBackgroundColor
) {
364 TestSharedBitmapManager shared_bitmap_manager
;
365 TestTaskGraphRunner task_graph_runner
;
366 scoped_ptr
<OutputSurface
> output_surface
= FakeOutputSurface::Create3d();
367 FakeLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
,
369 EXPECT_TRUE(host_impl
.InitializeRenderer(output_surface
.get()));
370 scoped_ptr
<LayerImpl
> layer
= LayerImpl::Create(host_impl
.active_tree(), 1);
372 for (int contents_opaque
= 0; contents_opaque
< 2; ++contents_opaque
) {
373 for (int layer_opaque
= 0; layer_opaque
< 2; ++layer_opaque
) {
374 for (int host_opaque
= 0; host_opaque
< 2; ++host_opaque
) {
375 layer
->SetContentsOpaque(!!contents_opaque
);
376 layer
->SetBackgroundColor(layer_opaque
? SK_ColorRED
377 : SK_ColorTRANSPARENT
);
378 host_impl
.active_tree()->set_background_color(
379 host_opaque
? SK_ColorRED
: SK_ColorTRANSPARENT
);
381 SkColor safe_color
= layer
->SafeOpaqueBackgroundColor();
382 if (contents_opaque
) {
383 EXPECT_EQ(SkColorGetA(safe_color
), 255u)
384 << "Flags: " << contents_opaque
<< ", " << layer_opaque
<< ", "
385 << host_opaque
<< "\n";
387 EXPECT_NE(SkColorGetA(safe_color
), 255u)
388 << "Flags: " << contents_opaque
<< ", " << layer_opaque
<< ", "
389 << host_opaque
<< "\n";
396 TEST(LayerImplTest
, TransformInvertibility
) {
398 TestSharedBitmapManager shared_bitmap_manager
;
399 TestTaskGraphRunner task_graph_runner
;
400 FakeLayerTreeHostImpl
host_impl(&proxy
, &shared_bitmap_manager
,
403 scoped_ptr
<LayerImpl
> layer
= LayerImpl::Create(host_impl
.active_tree(), 1);
404 EXPECT_TRUE(layer
->transform().IsInvertible());
405 EXPECT_TRUE(layer
->transform_is_invertible());
407 gfx::Transform transform
;
409 SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
410 layer
->SetTransform(transform
);
411 EXPECT_FALSE(layer
->transform().IsInvertible());
412 EXPECT_FALSE(layer
->transform_is_invertible());
414 transform
.MakeIdentity();
415 transform
.ApplyPerspectiveDepth(SkDoubleToMScalar(100.0));
416 transform
.RotateAboutZAxis(75.0);
417 transform
.RotateAboutXAxis(32.2);
418 transform
.RotateAboutZAxis(-75.0);
419 transform
.Translate3d(SkDoubleToMScalar(50.5),
420 SkDoubleToMScalar(42.42),
421 SkDoubleToMScalar(-100.25));
423 layer
->SetTransform(transform
);
424 EXPECT_TRUE(layer
->transform().IsInvertible());
425 EXPECT_TRUE(layer
->transform_is_invertible());
428 class LayerImplScrollTest
: public testing::Test
{
430 LayerImplScrollTest()
431 : host_impl_(settings(),
433 &shared_bitmap_manager_
,
434 &task_graph_runner_
),
436 host_impl_
.active_tree()->SetRootLayer(
437 LayerImpl::Create(host_impl_
.active_tree(), root_id_
));
438 host_impl_
.active_tree()->root_layer()->AddChild(
439 LayerImpl::Create(host_impl_
.active_tree(), root_id_
+ 1));
440 layer()->SetScrollClipLayer(root_id_
);
441 // Set the max scroll offset by noting that the root layer has bounds (1,1),
442 // thus whatever bounds are set for the layer will be the max scroll
443 // offset plus 1 in each direction.
444 host_impl_
.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1));
445 gfx::Vector2d
max_scroll_offset(51, 81);
446 layer()->SetBounds(gfx::Size(max_scroll_offset
.x(), max_scroll_offset
.y()));
450 return host_impl_
.active_tree()->root_layer()->children()[0];
453 LayerTreeHostImpl
& host_impl() { return host_impl_
; }
455 LayerTreeImpl
* tree() { return host_impl_
.active_tree(); }
457 LayerTreeSettings
settings() {
458 LayerTreeSettings settings
;
463 FakeImplProxy proxy_
;
464 TestSharedBitmapManager shared_bitmap_manager_
;
465 TestTaskGraphRunner task_graph_runner_
;
466 FakeLayerTreeHostImpl host_impl_
;
470 TEST_F(LayerImplScrollTest
, ScrollByWithZeroOffset
) {
471 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
472 // offset is bounded by the range [0, max scroll offset].
474 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->CurrentScrollOffset());
475 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
476 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
478 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
479 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->CurrentScrollOffset());
481 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->CurrentScrollOffset());
482 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
484 layer()->ScrollBy(gfx::Vector2dF(100, -100));
485 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->CurrentScrollOffset());
487 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->CurrentScrollOffset());
488 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
491 TEST_F(LayerImplScrollTest
, ScrollByWithNonZeroOffset
) {
492 gfx::ScrollOffset
scroll_offset(10, 5);
493 layer()->PushScrollOffsetFromMainThread(scroll_offset
);
495 EXPECT_VECTOR_EQ(scroll_offset
, layer()->CurrentScrollOffset());
496 EXPECT_VECTOR_EQ(scroll_offset
, layer()->BaseScrollOffset());
497 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
499 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
500 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->CurrentScrollOffset());
503 gfx::ScrollOffsetWithDelta(scroll_offset
, layer()->ScrollDelta()),
504 layer()->CurrentScrollOffset());
505 EXPECT_VECTOR_EQ(scroll_offset
, layer()->BaseScrollOffset());
507 layer()->ScrollBy(gfx::Vector2dF(100, -100));
508 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->CurrentScrollOffset());
511 gfx::ScrollOffsetWithDelta(scroll_offset
, layer()->ScrollDelta()),
512 layer()->CurrentScrollOffset());
513 EXPECT_VECTOR_EQ(scroll_offset
, layer()->BaseScrollOffset());
516 TEST_F(LayerImplScrollTest
, ApplySentScrollsNoListener
) {
517 gfx::ScrollOffset
scroll_offset(10, 5);
518 gfx::Vector2dF
scroll_delta(20.5f
, 8.5f
);
519 gfx::Vector2d
sent_scroll_delta(12, -3);
521 layer()->PushScrollOffsetFromMainThread(scroll_offset
);
522 layer()->ScrollBy(sent_scroll_delta
);
523 layer()->PullDeltaForMainThread();
524 layer()->SetCurrentScrollOffset(scroll_offset
+
525 gfx::ScrollOffset(scroll_delta
));
527 EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset
, scroll_delta
),
528 layer()->CurrentScrollOffset());
529 EXPECT_VECTOR_EQ(scroll_delta
, layer()->ScrollDelta());
530 EXPECT_VECTOR_EQ(scroll_offset
, layer()->BaseScrollOffset());
532 layer()->ApplySentScrollDeltasFromAbortedCommit();
534 EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset
, scroll_delta
),
535 layer()->CurrentScrollOffset());
536 EXPECT_VECTOR_EQ(scroll_delta
- sent_scroll_delta
, layer()->ScrollDelta());
537 EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset
, sent_scroll_delta
),
538 layer()->BaseScrollOffset());
541 TEST_F(LayerImplScrollTest
, ScrollUserUnscrollableLayer
) {
542 gfx::ScrollOffset
scroll_offset(10, 5);
543 gfx::Vector2dF
scroll_delta(20.5f
, 8.5f
);
545 layer()->set_user_scrollable_vertical(false);
546 layer()->PushScrollOffsetFromMainThread(scroll_offset
);
547 gfx::Vector2dF unscrolled
= layer()->ScrollBy(scroll_delta
);
549 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f
), unscrolled
);
550 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f
, 5), layer()->CurrentScrollOffset());
553 TEST_F(LayerImplScrollTest
, PushPropertiesToMirrorsCurrentScrollOffset
) {
554 gfx::ScrollOffset
scroll_offset(10, 5);
555 gfx::Vector2dF
scroll_delta(12, 18);
557 host_impl().CreatePendingTree();
559 layer()->PushScrollOffsetFromMainThread(scroll_offset
);
560 gfx::Vector2dF unscrolled
= layer()->ScrollBy(scroll_delta
);
562 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), unscrolled
);
563 EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->CurrentScrollOffset());
565 layer()->PullDeltaForMainThread();
567 scoped_ptr
<LayerImpl
> pending_layer
= LayerImpl::Create(
568 host_impl().sync_tree(), layer()->id(), layer()->synced_scroll_offset());
569 pending_layer
->PushScrollOffsetFromMainThread(layer()->CurrentScrollOffset());
571 pending_layer
->PushPropertiesTo(layer());
573 EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->CurrentScrollOffset());
574 EXPECT_VECTOR_EQ(layer()->CurrentScrollOffset(),
575 pending_layer
->CurrentScrollOffset());
578 TEST_F(LayerImplScrollTest
, SetNewScrollbarParameters
) {
579 gfx::ScrollOffset
scroll_offset(10, 5);
580 layer()->PushScrollOffsetFromMainThread(scroll_offset
);
582 scoped_ptr
<PaintedScrollbarLayerImpl
> vertical_scrollbar(
583 PaintedScrollbarLayerImpl::Create(tree(), 100, VERTICAL
));
584 vertical_scrollbar
->SetScrollLayerAndClipLayerByIds(
585 layer()->id(), tree()->root_layer()->id());
587 int expected_vertical_maximum
=
588 layer()->bounds().height() - tree()->root_layer()->bounds().height();
589 EXPECT_EQ(expected_vertical_maximum
, vertical_scrollbar
->maximum());
590 EXPECT_EQ(scroll_offset
.y(), vertical_scrollbar
->current_pos());
592 scoped_ptr
<PaintedScrollbarLayerImpl
> horizontal_scrollbar(
593 PaintedScrollbarLayerImpl::Create(tree(), 101, HORIZONTAL
));
594 horizontal_scrollbar
->SetScrollLayerAndClipLayerByIds(
595 layer()->id(), tree()->root_layer()->id());
597 int expected_horizontal_maximum
=
598 layer()->bounds().width() - tree()->root_layer()->bounds().width();
599 EXPECT_EQ(expected_horizontal_maximum
, horizontal_scrollbar
->maximum());
600 EXPECT_EQ(scroll_offset
.x(), horizontal_scrollbar
->current_pos());
603 class LayerImplScrollbarSyncTest
: public testing::Test
{
620 LayerImplScrollbarSyncTest()
621 : host_impl_(settings(),
623 &shared_bitmap_manager_
,
624 &task_graph_runner_
) {
625 host_impl_
.CreatePendingTree();
627 CreateLayers(host_impl_
.pending_tree());
628 CreateLayers(host_impl_
.active_tree());
631 void CreateLayers(LayerTreeImpl
* tree
) {
632 tree
->SetRootLayer(LayerImpl::Create(tree
, ROOT
));
633 LayerImpl
* root
= tree
->root_layer();
634 ASSERT_TRUE(root
!= nullptr);
636 int hierarchy
[] = {IV_CLIP
, PAGE
, IV_SCROLL
, OLD_ROOT
, OV_CLIP
, OV_SCROLL
};
637 LayerImpl
* parent
= root
;
638 for (int child_id
: hierarchy
) {
639 parent
->AddChild(LayerImpl::Create(tree
, child_id
));
640 parent
= tree
->LayerById(child_id
);
641 ASSERT_TRUE(parent
!= nullptr);
645 SolidColorScrollbarLayerImpl::Create(tree
, SCROLLBAR
, HORIZONTAL
,
649 LayerImpl
* layer(int id
, TreeID tree_id
) {
650 LayerTreeImpl
* tree
=
651 ((tree_id
== PENDING
) ?
652 host_impl_
.pending_tree() : host_impl_
.active_tree());
655 return tree
->LayerById(id
);
658 bool LayerHasScrollbar(int id
, TreeID tree_id
) {
659 return layer(id
, tree_id
)->HasScrollbar(HORIZONTAL
);
662 ScrollbarLayerImplBase
* pending_scrollbar() {
663 LayerImpl
* layer_impl
= layer(SCROLLBAR
, PENDING
);
665 return layer_impl
->ToScrollbarLayer();
668 LayerImpl
* pending_root() {
669 LayerImpl
* result
= layer(ROOT
, PENDING
);
674 LayerImpl
* active_root() {
675 LayerImpl
* result
= layer(ROOT
, ACTIVE
);
680 LayerTreeSettings
settings() {
681 LayerTreeSettings settings
;
686 FakeImplProxy proxy_
;
687 TestSharedBitmapManager shared_bitmap_manager_
;
688 TestTaskGraphRunner task_graph_runner_
;
689 FakeLayerTreeHostImpl host_impl_
;
692 TEST_F(LayerImplScrollbarSyncTest
, LayerImplBecomesScrollable
) {
693 // In the beginning IV_SCROLL layer is not scrollable.
694 ASSERT_FALSE(layer(IV_SCROLL
, PENDING
)->scrollable());
696 // For pinch virtual viewport the clip layer is the inner viewport
697 // clip layer (IV_CLIP) and the scroll one is the outer viewport
698 // scroll layer (OV_SCROLL).
699 pending_scrollbar()->SetScrollLayerAndClipLayerByIds(OV_SCROLL
, IV_CLIP
);
701 ASSERT_TRUE(LayerHasScrollbar(OV_SCROLL
, PENDING
));
702 ASSERT_TRUE(LayerHasScrollbar(IV_CLIP
, PENDING
));
704 // Synchronize with the active tree.
705 TreeSynchronizer::PushProperties(pending_root(), active_root());
707 ASSERT_TRUE(LayerHasScrollbar(OV_SCROLL
, ACTIVE
));
708 ASSERT_TRUE(LayerHasScrollbar(IV_CLIP
, ACTIVE
));
710 // Make IV_SCROLL layer scrollable.
711 layer(IV_SCROLL
, PENDING
)->SetScrollClipLayer(IV_CLIP
);
712 layer(IV_SCROLL
, PENDING
)->SetNeedsPushProperties();
713 ASSERT_TRUE(layer(IV_SCROLL
, PENDING
)->scrollable());
715 pending_scrollbar()->SetScrollLayerAndClipLayerByIds(OV_SCROLL
, IV_CLIP
);
717 // Now IV_CLIP layer should also receive the scrollbar.
718 ASSERT_TRUE(LayerHasScrollbar(OV_SCROLL
, PENDING
));
719 ASSERT_TRUE(LayerHasScrollbar(IV_CLIP
, PENDING
));
720 ASSERT_TRUE(LayerHasScrollbar(IV_SCROLL
, PENDING
));
722 // Synchronize with the active tree.
723 TreeSynchronizer::PushProperties(pending_root(), active_root());
725 ASSERT_TRUE(layer(IV_SCROLL
, ACTIVE
)->scrollable());
727 ASSERT_TRUE(LayerHasScrollbar(OV_SCROLL
, ACTIVE
));
728 ASSERT_TRUE(LayerHasScrollbar(IV_CLIP
, ACTIVE
));
729 ASSERT_TRUE(LayerHasScrollbar(IV_SCROLL
, ACTIVE
));