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/output/filter_operation.h"
8 #include "cc/output/filter_operations.h"
9 #include "cc/test/fake_impl_proxy.h"
10 #include "cc/test/fake_layer_tree_host_impl.h"
11 #include "cc/test/fake_output_surface.h"
12 #include "cc/test/geometry_test_utils.h"
13 #include "cc/trees/layer_tree_impl.h"
14 #include "cc/trees/single_thread_proxy.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
22 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \
23 root->ResetAllChangeTrackingForSubtree(); \
25 EXPECT_TRUE(root->LayerPropertyChanged()); \
26 EXPECT_TRUE(child->LayerPropertyChanged()); \
27 EXPECT_TRUE(grand_child->LayerPropertyChanged());
29 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \
30 root->ResetAllChangeTrackingForSubtree(); \
32 EXPECT_FALSE(root->LayerPropertyChanged()); \
33 EXPECT_FALSE(child->LayerPropertyChanged()); \
34 EXPECT_FALSE(grand_child->LayerPropertyChanged());
36 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \
37 root->ResetAllChangeTrackingForSubtree(); \
39 EXPECT_TRUE(root->LayerPropertyChanged()); \
40 EXPECT_FALSE(child->LayerPropertyChanged()); \
41 EXPECT_FALSE(grand_child->LayerPropertyChanged());
43 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
44 root->ResetAllChangeTrackingForSubtree(); \
45 host_impl.ForcePrepareToDraw(); \
46 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \
48 EXPECT_TRUE(host_impl.active_tree()->needs_update_draw_properties());
50 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
51 root->ResetAllChangeTrackingForSubtree(); \
52 host_impl.ForcePrepareToDraw(); \
53 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \
55 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());
57 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
59 // This test checks that layerPropertyChanged() has the correct behavior.
62 // The constructor on this will fake that we are on the correct thread.
63 // Create a simple LayerImpl tree:
65 FakeLayerTreeHostImpl host_impl(&proxy);
66 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
67 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
68 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
69 LayerImpl* child = root->children()[0];
70 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 3));
71 LayerImpl* grand_child = child->children()[0];
73 root->SetScrollable(true);
75 // Adding children is an internal operation and should not mark layers as
77 EXPECT_FALSE(root->LayerPropertyChanged());
78 EXPECT_FALSE(child->LayerPropertyChanged());
79 EXPECT_FALSE(grand_child->LayerPropertyChanged());
81 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
82 float arbitrary_number = 0.352f;
83 gfx::Size arbitrary_size = gfx::Size(111, 222);
84 gfx::Point arbitrary_point = gfx::Point(333, 444);
85 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
86 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
87 gfx::RectF arbitrary_rect_f =
88 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
89 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
90 gfx::Transform arbitrary_transform;
91 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
92 FilterOperations arbitrary_filters;
93 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
95 // These properties are internal, and should not be considered "change" when
97 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
98 root->set_update_rect(arbitrary_rect_f));
99 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
100 root->SetMaxScrollOffset(arbitrary_vector2d));
102 // Changing these properties affects the entire subtree of layers.
103 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f));
104 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number));
105 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
106 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations()));
107 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
108 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
109 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true));
110 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true));
111 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
112 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
113 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f));
114 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true));
115 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
116 root->SetDoubleSided(false)); // constructor initializes it to "true".
117 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
118 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d()));
119 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d));
120 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true));
121 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number));
122 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform));
124 // Changing these properties only affects the layer itself.
125 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetContentBounds(arbitrary_size));
126 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
127 root->SetContentsScale(arbitrary_number, arbitrary_number));
128 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true));
129 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
130 root->SetBackgroundColor(arbitrary_color));
131 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
132 root->SetBackgroundFilters(arbitrary_filters));
134 // Special case: check that sublayer transform changes all layer's
135 // descendants, but not the layer itself.
136 root->ResetAllChangeTrackingForSubtree();
137 root->SetSublayerTransform(arbitrary_transform);
138 EXPECT_FALSE(root->LayerPropertyChanged());
139 EXPECT_TRUE(child->LayerPropertyChanged());
140 EXPECT_TRUE(grand_child->LayerPropertyChanged());
142 // Special case: check that SetBounds changes behavior depending on
144 root->SetMasksToBounds(false);
145 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246)));
146 root->SetMasksToBounds(true);
147 // Should be a different size than previous call, to ensure it marks tree
149 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size));
151 // After setting all these properties already, setting to the exact same
152 // values again should not cause any change.
153 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
154 root->SetAnchorPoint(arbitrary_point_f));
155 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
156 root->SetAnchorPointZ(arbitrary_number));
157 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true));
158 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
159 root->SetPosition(arbitrary_point_f));
160 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetPreserves3d(true));
161 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
162 root->SetTransform(arbitrary_transform));
163 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
164 root->SetDoubleSided(false)); // constructor initializes it to "true".
165 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
166 root->SetScrollDelta(gfx::Vector2d()));
167 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
168 root->SetScrollOffset(arbitrary_vector2d));
169 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
170 root->SetContentBounds(arbitrary_size));
171 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
172 root->SetContentsScale(arbitrary_number, arbitrary_number));
173 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true));
174 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number));
175 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
176 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
177 root->SetSublayerTransform(arbitrary_transform));
178 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size));
181 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
183 FakeLayerTreeHostImpl host_impl(&proxy);
184 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
185 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
186 root->SetScrollable(true);
188 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
189 float arbitrary_number = 0.352f;
190 gfx::Size arbitrary_size = gfx::Size(111, 222);
191 gfx::Point arbitrary_point = gfx::Point(333, 444);
192 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
193 gfx::Vector2d large_vector2d = gfx::Vector2d(1000, 1000);
194 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
195 gfx::RectF arbitrary_rect_f =
196 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
197 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
198 gfx::Transform arbitrary_transform;
199 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
200 FilterOperations arbitrary_filters;
201 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
203 // Related filter functions.
204 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
205 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
206 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations()));
207 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
209 // Related scrolling functions.
210 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d));
211 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
212 root->SetMaxScrollOffset(large_vector2d));
213 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d));
214 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d()));
215 root->SetScrollDelta(gfx::Vector2d(0, 0));
216 host_impl.ForcePrepareToDraw();
217 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d));
218 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
219 root->SetScrollDelta(arbitrary_vector2d));
220 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
221 root->SetScrollOffset(arbitrary_vector2d));
222 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
223 root->SetScrollOffset(arbitrary_vector2d));
225 // Unrelated functions, always set to new values, always set needs update.
226 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetAnchorPointZ(arbitrary_number));
227 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
228 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
229 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
230 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
231 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
232 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
233 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
234 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
235 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
236 root->SetDoubleSided(false)); // constructor initializes it to "true".
237 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentBounds(arbitrary_size));
238 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
239 root->SetContentsScale(arbitrary_number, arbitrary_number));
240 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
241 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
242 root->SetBackgroundColor(arbitrary_color));
243 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
244 root->SetBackgroundFilters(arbitrary_filters));
245 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
246 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetTransform(arbitrary_transform));
247 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
248 root->SetSublayerTransform(arbitrary_transform));
249 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
251 // Unrelated functions, set to the same values, no needs update.
252 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
253 root->SetAnchorPointZ(arbitrary_number));
254 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
255 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
256 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
257 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
258 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
259 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
260 root->SetDoubleSided(false)); // constructor initializes it to "true".
261 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
262 root->SetContentBounds(arbitrary_size));
263 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
264 root->SetContentsScale(arbitrary_number, arbitrary_number));
265 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
266 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
267 root->SetBackgroundColor(arbitrary_color));
268 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
269 root->SetBackgroundFilters(arbitrary_filters));
270 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
271 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
272 root->SetTransform(arbitrary_transform));
273 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
274 root->SetSublayerTransform(arbitrary_transform));
275 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
278 TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
280 FakeLayerTreeHostImpl host_impl(&proxy);
281 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
282 scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1);
284 for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
285 for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
286 for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
287 layer->SetContentsOpaque(!!contents_opaque);
288 layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
289 : SK_ColorTRANSPARENT);
290 host_impl.active_tree()->set_background_color(
291 host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT);
293 SkColor safe_color = layer->SafeOpaqueBackgroundColor();
294 if (contents_opaque) {
295 EXPECT_EQ(SkColorGetA(safe_color), 255u)
296 << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
297 << host_opaque << "\n";
299 EXPECT_NE(SkColorGetA(safe_color), 255u)
300 << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
301 << host_opaque << "\n";
308 class LayerImplScrollTest : public testing::Test {
310 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) {
311 host_impl_.active_tree()
312 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_));
313 host_impl_.active_tree()->root_layer()->SetScrollable(true);
316 LayerImpl* layer() { return host_impl_.active_tree()->root_layer(); }
319 FakeImplProxy proxy_;
320 FakeLayerTreeHostImpl host_impl_;
324 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) {
325 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
326 // offset is bounded by the range [0, max scroll offset].
327 gfx::Vector2d max_scroll_offset(50, 80);
328 layer()->SetMaxScrollOffset(max_scroll_offset);
330 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset());
331 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
332 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
334 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
335 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
337 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset());
338 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
340 layer()->ScrollBy(gfx::Vector2dF(100, -100));
341 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset());
343 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset());
344 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
347 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
348 gfx::Vector2d max_scroll_offset(50, 80);
349 gfx::Vector2d scroll_offset(10, 5);
350 layer()->SetMaxScrollOffset(max_scroll_offset);
351 layer()->SetScrollOffset(scroll_offset);
353 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
354 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
355 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
357 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
358 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
360 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset,
361 layer()->TotalScrollOffset());
362 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
364 layer()->ScrollBy(gfx::Vector2dF(100, -100));
365 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset());
367 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset,
368 layer()->TotalScrollOffset());
369 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
372 class ScrollDelegateIgnore : public LayerScrollOffsetDelegate {
374 virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {}
375 virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE {}
376 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
377 return fixed_offset_;
379 virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
381 void set_fixed_offset(gfx::Vector2dF fixed_offset) {
382 fixed_offset_ = fixed_offset;
385 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {}
386 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {}
389 gfx::Vector2dF fixed_offset_;
392 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
393 gfx::Vector2d max_scroll_offset(50, 80);
394 gfx::Vector2d scroll_offset(10, 5);
395 layer()->SetMaxScrollOffset(max_scroll_offset);
396 layer()->SetScrollOffset(scroll_offset);
398 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
399 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
400 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
402 ScrollDelegateIgnore delegate;
403 gfx::Vector2dF fixed_offset(32, 12);
404 delegate.set_fixed_offset(fixed_offset);
405 layer()->SetScrollOffsetDelegate(&delegate);
407 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
408 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
410 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
412 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
413 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
415 layer()->SetScrollOffsetDelegate(NULL);
417 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
418 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
420 gfx::Vector2dF scroll_delta(1, 1);
421 layer()->ScrollBy(scroll_delta);
423 EXPECT_VECTOR_EQ(fixed_offset + scroll_delta, layer()->TotalScrollOffset());
424 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
427 class ScrollDelegateAccept : public LayerScrollOffsetDelegate {
429 virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {}
430 virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE {
431 current_offset_ = new_value;
433 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
434 return current_offset_;
436 virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
437 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {}
438 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {}
441 gfx::Vector2dF current_offset_;
444 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) {
445 gfx::Vector2d max_scroll_offset(50, 80);
446 gfx::Vector2d scroll_offset(10, 5);
447 layer()->SetMaxScrollOffset(max_scroll_offset);
448 layer()->SetScrollOffset(scroll_offset);
450 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
451 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
452 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
454 ScrollDelegateAccept delegate;
455 layer()->SetScrollOffsetDelegate(&delegate);
457 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
458 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
459 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
461 layer()->ScrollBy(gfx::Vector2dF(-100, 100));
463 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
464 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
466 layer()->SetScrollOffsetDelegate(NULL);
468 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
469 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
471 gfx::Vector2dF scroll_delta(1, 1);
472 layer()->ScrollBy(scroll_delta);
474 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset());
475 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
478 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) {
479 gfx::Vector2d max_scroll_offset(50, 80);
480 gfx::Vector2d scroll_offset(10, 5);
481 gfx::Vector2dF scroll_delta(20.5f, 8.5f);
482 gfx::Vector2d sent_scroll_delta(12, -3);
484 layer()->SetMaxScrollOffset(max_scroll_offset);
485 layer()->SetScrollOffset(scroll_offset);
486 layer()->ScrollBy(scroll_delta);
487 layer()->SetSentScrollDelta(sent_scroll_delta);
489 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset());
490 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta());
491 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
492 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
494 layer()->ApplySentScrollDeltasFromAbortedCommit();
496 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset());
497 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta());
498 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset());
499 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
502 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
503 gfx::Vector2d max_scroll_offset(50, 80);
504 gfx::Vector2d scroll_offset(10, 5);
505 gfx::Vector2d sent_scroll_delta(12, -3);
506 gfx::Vector2dF fixed_offset(32, 12);
508 layer()->SetMaxScrollOffset(max_scroll_offset);
509 layer()->SetScrollOffset(scroll_offset);
510 ScrollDelegateIgnore delegate;
511 delegate.set_fixed_offset(fixed_offset);
512 layer()->SetScrollOffsetDelegate(&delegate);
513 layer()->SetSentScrollDelta(sent_scroll_delta);
515 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
516 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
517 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
519 layer()->ApplySentScrollDeltasFromAbortedCommit();
521 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
522 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset());
523 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
526 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
527 gfx::Vector2d max_scroll_offset(50, 80);
528 gfx::Vector2d scroll_offset(10, 5);
529 gfx::Vector2d sent_scroll_delta(12, -3);
530 gfx::Vector2dF scroll_delta(20.5f, 8.5f);
532 layer()->SetMaxScrollOffset(max_scroll_offset);
533 layer()->SetScrollOffset(scroll_offset);
534 ScrollDelegateAccept delegate;
535 layer()->SetScrollOffsetDelegate(&delegate);
536 layer()->ScrollBy(scroll_delta);
537 layer()->SetSentScrollDelta(sent_scroll_delta);
539 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset());
540 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
541 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
543 layer()->ApplySentScrollDeltasFromAbortedCommit();
545 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset());
546 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset());
547 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
550 TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
551 gfx::Vector2d max_scroll_offset(50, 80);
552 gfx::Vector2d scroll_offset(10, 5);
553 gfx::Vector2dF scroll_delta(20.5f, 8.5f);
555 layer()->set_user_scrollable_vertical(false);
556 layer()->SetMaxScrollOffset(max_scroll_offset);
557 layer()->SetScrollOffset(scroll_offset);
558 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
560 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled);
561 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset());