OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/layers/layer_impl.h" | 5 #include "cc/layers/layer_impl.h" |
6 | 6 |
7 #include "cc/output/filter_operation.h" | 7 #include "cc/output/filter_operation.h" |
8 #include "cc/output/filter_operations.h" | 8 #include "cc/output/filter_operations.h" |
9 #include "cc/test/fake_impl_proxy.h" | 9 #include "cc/test/fake_impl_proxy.h" |
10 #include "cc/test/fake_layer_tree_host_impl.h" | 10 #include "cc/test/fake_layer_tree_host_impl.h" |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
87 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { | 87 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { |
88 // | 88 // |
89 // This test checks that layerPropertyChanged() has the correct behavior. | 89 // This test checks that layerPropertyChanged() has the correct behavior. |
90 // | 90 // |
91 | 91 |
92 // The constructor on this will fake that we are on the correct thread. | 92 // The constructor on this will fake that we are on the correct thread. |
93 // Create a simple LayerImpl tree: | 93 // Create a simple LayerImpl tree: |
94 FakeImplProxy proxy; | 94 FakeImplProxy proxy; |
95 FakeLayerTreeHostImpl host_impl(&proxy); | 95 FakeLayerTreeHostImpl host_impl(&proxy); |
96 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); | 96 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); |
97 scoped_ptr<LayerImpl> root_clip = | 97 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); |
98 LayerImpl::Create(host_impl.active_tree(), 1); | 98 |
99 scoped_ptr<LayerImpl> root_ptr = | 99 scoped_ptr<LayerImpl> scroll_parent = |
100 LayerImpl::Create(host_impl.active_tree(), 2); | 100 LayerImpl::Create(host_impl.active_tree(), 2); |
101 LayerImpl* root = root_ptr.get(); | 101 LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 3).get(); |
102 root_clip->AddChild(root_ptr.Pass()); | |
103 scoped_ptr<LayerImpl> scroll_parent = | |
104 LayerImpl::Create(host_impl.active_tree(), 3); | |
105 LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 4).get(); | |
106 std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>(); | 102 std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>(); |
107 scroll_children->insert(scroll_child); | 103 scroll_children->insert(scroll_child); |
108 scroll_children->insert(root); | 104 scroll_children->insert(root.get()); |
109 | 105 |
110 scoped_ptr<LayerImpl> clip_parent = | 106 scoped_ptr<LayerImpl> clip_parent = |
111 LayerImpl::Create(host_impl.active_tree(), 5); | 107 LayerImpl::Create(host_impl.active_tree(), 4); |
112 LayerImpl* clip_child = LayerImpl::Create(host_impl.active_tree(), 6).get(); | 108 LayerImpl* clip_child = LayerImpl::Create(host_impl.active_tree(), 5).get(); |
113 std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>(); | 109 std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>(); |
114 clip_children->insert(clip_child); | 110 clip_children->insert(clip_child); |
115 clip_children->insert(root); | 111 clip_children->insert(root.get()); |
116 | 112 |
117 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 7)); | 113 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 6)); |
118 LayerImpl* child = root->children()[0]; | 114 LayerImpl* child = root->children()[0]; |
119 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 8)); | 115 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 7)); |
120 LayerImpl* grand_child = child->children()[0]; | 116 LayerImpl* grand_child = child->children()[0]; |
121 | 117 |
122 root->SetScrollClipLayer(root_clip->id()); | 118 root->SetScrollable(true); |
123 | 119 |
124 // Adding children is an internal operation and should not mark layers as | 120 // Adding children is an internal operation and should not mark layers as |
125 // changed. | 121 // changed. |
126 EXPECT_FALSE(root->LayerPropertyChanged()); | 122 EXPECT_FALSE(root->LayerPropertyChanged()); |
127 EXPECT_FALSE(child->LayerPropertyChanged()); | 123 EXPECT_FALSE(child->LayerPropertyChanged()); |
128 EXPECT_FALSE(grand_child->LayerPropertyChanged()); | 124 EXPECT_FALSE(grand_child->LayerPropertyChanged()); |
129 | 125 |
130 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); | 126 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); |
131 float arbitrary_number = 0.352f; | 127 float arbitrary_number = 0.352f; |
132 gfx::Size arbitrary_size = gfx::Size(111, 222); | 128 gfx::Size arbitrary_size = gfx::Size(111, 222); |
133 gfx::Point arbitrary_point = gfx::Point(333, 444); | 129 gfx::Point arbitrary_point = gfx::Point(333, 444); |
134 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); | 130 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); |
135 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); | 131 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); |
136 gfx::RectF arbitrary_rect_f = | 132 gfx::RectF arbitrary_rect_f = |
137 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); | 133 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); |
138 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); | 134 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); |
139 gfx::Transform arbitrary_transform; | 135 gfx::Transform arbitrary_transform; |
140 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); | 136 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); |
141 FilterOperations arbitrary_filters; | 137 FilterOperations arbitrary_filters; |
142 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); | 138 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); |
143 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; | 139 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; |
144 | 140 |
145 // These properties are internal, and should not be considered "change" when | 141 // These properties are internal, and should not be considered "change" when |
146 // they are used. | 142 // they are used. |
147 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( | 143 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( |
148 root->SetUpdateRect(arbitrary_rect_f)); | 144 root->SetUpdateRect(arbitrary_rect_f)); |
149 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size)); | 145 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( |
| 146 root->SetMaxScrollOffset(arbitrary_vector2d)); |
150 | 147 |
151 // Changing these properties affects the entire subtree of layers. | 148 // Changing these properties affects the entire subtree of layers. |
152 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); | 149 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); |
153 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); | 150 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); |
154 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); | 151 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); |
155 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); | 152 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); |
156 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 153 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
157 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 9))); | 154 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 8))); |
158 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); | 155 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); |
159 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); | 156 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); |
160 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 157 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
161 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 10))); | 158 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 9))); |
162 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); | 159 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); |
163 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true)); | 160 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true)); |
164 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 161 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
165 root->SetDoubleSided(false)); // constructor initializes it to "true". | 162 root->SetDoubleSided(false)); // constructor initializes it to "true". |
166 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); | 163 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); |
167 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); | 164 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); |
168 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); | 165 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); |
169 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); | 166 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); |
170 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number)); | 167 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number)); |
171 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode)); | 168 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode)); |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
253 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( | 250 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( |
254 root->SetClipParent(clip_parent.get())); | 251 root->SetClipParent(clip_parent.get())); |
255 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( | 252 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( |
256 root->SetClipChildren(clip_children)); | 253 root->SetClipChildren(clip_children)); |
257 } | 254 } |
258 | 255 |
259 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { | 256 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { |
260 FakeImplProxy proxy; | 257 FakeImplProxy proxy; |
261 FakeLayerTreeHostImpl host_impl(&proxy); | 258 FakeLayerTreeHostImpl host_impl(&proxy); |
262 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); | 259 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); |
263 scoped_ptr<LayerImpl> root_clip = | 260 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); |
264 LayerImpl::Create(host_impl.active_tree(), 1); | 261 root->SetScrollable(true); |
265 root_clip->AddChild(LayerImpl::Create(host_impl.active_tree(), 2)); | |
266 LayerImpl* root = root_clip->children()[0]; | |
267 root->SetScrollClipLayer(root_clip->id()); | |
268 | 262 |
269 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); | 263 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); |
270 float arbitrary_number = 0.352f; | 264 float arbitrary_number = 0.352f; |
271 gfx::Size arbitrary_size = gfx::Size(111, 222); | 265 gfx::Size arbitrary_size = gfx::Size(111, 222); |
272 gfx::Point arbitrary_point = gfx::Point(333, 444); | 266 gfx::Point arbitrary_point = gfx::Point(333, 444); |
273 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); | 267 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); |
274 gfx::Size large_size = gfx::Size(1000, 1000); | 268 gfx::Vector2d large_vector2d = gfx::Vector2d(1000, 1000); |
275 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); | 269 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); |
276 gfx::RectF arbitrary_rect_f = | 270 gfx::RectF arbitrary_rect_f = |
277 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); | 271 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); |
278 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); | 272 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); |
279 gfx::Transform arbitrary_transform; | 273 gfx::Transform arbitrary_transform; |
280 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); | 274 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); |
281 FilterOperations arbitrary_filters; | 275 FilterOperations arbitrary_filters; |
282 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); | 276 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); |
283 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; | 277 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; |
284 | 278 |
285 // Related filter functions. | 279 // Related filter functions. |
286 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 280 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
287 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 281 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
288 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); | 282 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); |
289 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 283 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
290 | 284 |
291 // Related scrolling functions. | 285 // Related scrolling functions. |
292 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(large_size)); | 286 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d)); |
293 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 287 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
294 root->SetBounds(large_size)); | 288 root->SetMaxScrollOffset(large_vector2d)); |
295 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d)); | 289 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d)); |
296 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d())); | 290 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d())); |
297 root->SetScrollDelta(gfx::Vector2d(0, 0)); | 291 root->SetScrollDelta(gfx::Vector2d(0, 0)); |
298 host_impl.ForcePrepareToDraw(); | 292 host_impl.ForcePrepareToDraw(); |
299 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d)); | 293 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d)); |
300 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 294 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
301 root->SetScrollDelta(arbitrary_vector2d)); | 295 root->SetScrollDelta(arbitrary_vector2d)); |
302 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( | 296 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( |
303 root->SetScrollOffset(arbitrary_vector2d)); | 297 root->SetScrollOffset(arbitrary_vector2d)); |
304 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 298 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
390 } | 384 } |
391 } | 385 } |
392 } | 386 } |
393 } | 387 } |
394 | 388 |
395 class LayerImplScrollTest : public testing::Test { | 389 class LayerImplScrollTest : public testing::Test { |
396 public: | 390 public: |
397 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) { | 391 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) { |
398 host_impl_.active_tree() | 392 host_impl_.active_tree() |
399 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_)); | 393 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_)); |
400 host_impl_.active_tree()->root_layer()->AddChild( | 394 host_impl_.active_tree()->root_layer()->SetScrollable(true); |
401 LayerImpl::Create(host_impl_.active_tree(), root_id_ + 1)); | |
402 layer()->SetScrollClipLayer(root_id_); | |
403 // Set the max scroll offset by noting that the root layer has bounds (1,1), | |
404 // thus whatever bounds are set for the layer will be the max scroll | |
405 // offset plus 1 in each direction. | |
406 host_impl_.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1)); | |
407 gfx::Vector2d max_scroll_offset(51, 81); | |
408 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); | |
409 } | 395 } |
410 | 396 |
411 LayerImpl* layer() { | 397 LayerImpl* layer() { return host_impl_.active_tree()->root_layer(); } |
412 return host_impl_.active_tree()->root_layer()->children()[0]; | |
413 } | |
414 | 398 |
415 private: | 399 private: |
416 FakeImplProxy proxy_; | 400 FakeImplProxy proxy_; |
417 FakeLayerTreeHostImpl host_impl_; | 401 FakeLayerTreeHostImpl host_impl_; |
418 int root_id_; | 402 int root_id_; |
419 }; | 403 }; |
420 | 404 |
421 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { | 405 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { |
422 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll | 406 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll |
423 // offset is bounded by the range [0, max scroll offset]. | 407 // offset is bounded by the range [0, max scroll offset]. |
| 408 gfx::Vector2d max_scroll_offset(50, 80); |
| 409 layer()->SetMaxScrollOffset(max_scroll_offset); |
424 | 410 |
425 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); | 411 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); |
426 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 412 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
427 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 413 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
428 | 414 |
429 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); | 415 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); |
430 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); | 416 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); |
431 | 417 |
432 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); | 418 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); |
433 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 419 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
434 | 420 |
435 layer()->ScrollBy(gfx::Vector2dF(100, -100)); | 421 layer()->ScrollBy(gfx::Vector2dF(100, -100)); |
436 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); | 422 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); |
437 | 423 |
438 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); | 424 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); |
439 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 425 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
440 } | 426 } |
441 | 427 |
442 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { | 428 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { |
| 429 gfx::Vector2d max_scroll_offset(50, 80); |
443 gfx::Vector2d scroll_offset(10, 5); | 430 gfx::Vector2d scroll_offset(10, 5); |
| 431 layer()->SetMaxScrollOffset(max_scroll_offset); |
444 layer()->SetScrollOffset(scroll_offset); | 432 layer()->SetScrollOffset(scroll_offset); |
445 | 433 |
446 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 434 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
447 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 435 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
448 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 436 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
449 | 437 |
450 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); | 438 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); |
451 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); | 439 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); |
452 | 440 |
453 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, | 441 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, |
(...skipping 23 matching lines...) Expand all Loading... |
477 } | 465 } |
478 | 466 |
479 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} | 467 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} |
480 virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {} | 468 virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {} |
481 | 469 |
482 private: | 470 private: |
483 gfx::Vector2dF fixed_offset_; | 471 gfx::Vector2dF fixed_offset_; |
484 }; | 472 }; |
485 | 473 |
486 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { | 474 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { |
| 475 gfx::Vector2d max_scroll_offset(50, 80); |
487 gfx::Vector2d scroll_offset(10, 5); | 476 gfx::Vector2d scroll_offset(10, 5); |
| 477 layer()->SetMaxScrollOffset(max_scroll_offset); |
488 layer()->SetScrollOffset(scroll_offset); | 478 layer()->SetScrollOffset(scroll_offset); |
489 | 479 |
490 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 480 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
491 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 481 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
492 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 482 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
493 | 483 |
494 ScrollDelegateIgnore delegate; | 484 ScrollDelegateIgnore delegate; |
495 gfx::Vector2dF fixed_offset(32, 12); | 485 gfx::Vector2dF fixed_offset(32, 12); |
496 delegate.set_fixed_offset(fixed_offset); | 486 delegate.set_fixed_offset(fixed_offset); |
497 layer()->SetScrollOffsetDelegate(&delegate); | 487 layer()->SetScrollOffsetDelegate(&delegate); |
(...skipping 30 matching lines...) Expand all Loading... |
528 } | 518 } |
529 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } | 519 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } |
530 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} | 520 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} |
531 virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {} | 521 virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {} |
532 | 522 |
533 private: | 523 private: |
534 gfx::Vector2dF current_offset_; | 524 gfx::Vector2dF current_offset_; |
535 }; | 525 }; |
536 | 526 |
537 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { | 527 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { |
| 528 gfx::Vector2d max_scroll_offset(50, 80); |
538 gfx::Vector2d scroll_offset(10, 5); | 529 gfx::Vector2d scroll_offset(10, 5); |
| 530 layer()->SetMaxScrollOffset(max_scroll_offset); |
539 layer()->SetScrollOffset(scroll_offset); | 531 layer()->SetScrollOffset(scroll_offset); |
540 | 532 |
541 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 533 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
542 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 534 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
543 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 535 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
544 | 536 |
545 ScrollDelegateAccept delegate; | 537 ScrollDelegateAccept delegate; |
546 layer()->SetScrollOffsetDelegate(&delegate); | 538 layer()->SetScrollOffsetDelegate(&delegate); |
547 | 539 |
548 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 540 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
(...skipping 11 matching lines...) Expand all Loading... |
560 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 552 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
561 | 553 |
562 gfx::Vector2dF scroll_delta(1, 1); | 554 gfx::Vector2dF scroll_delta(1, 1); |
563 layer()->ScrollBy(scroll_delta); | 555 layer()->ScrollBy(scroll_delta); |
564 | 556 |
565 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); | 557 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); |
566 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 558 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
567 } | 559 } |
568 | 560 |
569 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { | 561 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { |
| 562 gfx::Vector2d max_scroll_offset(50, 80); |
570 gfx::Vector2d scroll_offset(10, 5); | 563 gfx::Vector2d scroll_offset(10, 5); |
571 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 564 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
572 gfx::Vector2d sent_scroll_delta(12, -3); | 565 gfx::Vector2d sent_scroll_delta(12, -3); |
573 | 566 |
| 567 layer()->SetMaxScrollOffset(max_scroll_offset); |
574 layer()->SetScrollOffset(scroll_offset); | 568 layer()->SetScrollOffset(scroll_offset); |
575 layer()->ScrollBy(scroll_delta); | 569 layer()->ScrollBy(scroll_delta); |
576 layer()->SetSentScrollDelta(sent_scroll_delta); | 570 layer()->SetSentScrollDelta(sent_scroll_delta); |
577 | 571 |
578 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 572 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
579 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); | 573 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); |
580 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 574 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
581 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 575 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
582 | 576 |
583 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 577 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
584 | 578 |
585 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 579 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
586 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); | 580 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); |
587 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 581 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
588 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 582 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
589 } | 583 } |
590 | 584 |
591 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { | 585 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { |
| 586 gfx::Vector2d max_scroll_offset(50, 80); |
592 gfx::Vector2d scroll_offset(10, 5); | 587 gfx::Vector2d scroll_offset(10, 5); |
593 gfx::Vector2d sent_scroll_delta(12, -3); | 588 gfx::Vector2d sent_scroll_delta(12, -3); |
594 gfx::Vector2dF fixed_offset(32, 12); | 589 gfx::Vector2dF fixed_offset(32, 12); |
595 | 590 |
| 591 layer()->SetMaxScrollOffset(max_scroll_offset); |
596 layer()->SetScrollOffset(scroll_offset); | 592 layer()->SetScrollOffset(scroll_offset); |
597 ScrollDelegateIgnore delegate; | 593 ScrollDelegateIgnore delegate; |
598 delegate.set_fixed_offset(fixed_offset); | 594 delegate.set_fixed_offset(fixed_offset); |
599 layer()->SetScrollOffsetDelegate(&delegate); | 595 layer()->SetScrollOffsetDelegate(&delegate); |
600 layer()->SetSentScrollDelta(sent_scroll_delta); | 596 layer()->SetSentScrollDelta(sent_scroll_delta); |
601 | 597 |
602 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); | 598 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); |
603 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 599 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
604 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 600 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
605 | 601 |
606 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 602 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
607 | 603 |
608 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); | 604 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); |
609 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 605 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
610 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 606 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
611 } | 607 } |
612 | 608 |
613 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { | 609 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { |
| 610 gfx::Vector2d max_scroll_offset(50, 80); |
614 gfx::Vector2d scroll_offset(10, 5); | 611 gfx::Vector2d scroll_offset(10, 5); |
615 gfx::Vector2d sent_scroll_delta(12, -3); | 612 gfx::Vector2d sent_scroll_delta(12, -3); |
616 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 613 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
617 | 614 |
| 615 layer()->SetMaxScrollOffset(max_scroll_offset); |
618 layer()->SetScrollOffset(scroll_offset); | 616 layer()->SetScrollOffset(scroll_offset); |
619 ScrollDelegateAccept delegate; | 617 ScrollDelegateAccept delegate; |
620 layer()->SetScrollOffsetDelegate(&delegate); | 618 layer()->SetScrollOffsetDelegate(&delegate); |
621 layer()->ScrollBy(scroll_delta); | 619 layer()->ScrollBy(scroll_delta); |
622 layer()->SetSentScrollDelta(sent_scroll_delta); | 620 layer()->SetSentScrollDelta(sent_scroll_delta); |
623 | 621 |
624 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 622 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
625 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 623 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
626 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 624 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
627 | 625 |
628 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 626 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
629 | 627 |
630 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 628 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
631 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 629 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
632 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 630 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
633 } | 631 } |
634 | 632 |
635 // The user-scrollability breaks for zoomed-in pages. So disable this. | 633 // The user-scrollability breaks for zoomed-in pages. So disable this. |
636 // http://crbug.com/322223 | 634 // http://crbug.com/322223 |
637 TEST_F(LayerImplScrollTest, DISABLED_ScrollUserUnscrollableLayer) { | 635 TEST_F(LayerImplScrollTest, DISABLED_ScrollUserUnscrollableLayer) { |
| 636 gfx::Vector2d max_scroll_offset(50, 80); |
638 gfx::Vector2d scroll_offset(10, 5); | 637 gfx::Vector2d scroll_offset(10, 5); |
639 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 638 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
640 | 639 |
641 layer()->set_user_scrollable_vertical(false); | 640 layer()->set_user_scrollable_vertical(false); |
| 641 layer()->SetMaxScrollOffset(max_scroll_offset); |
642 layer()->SetScrollOffset(scroll_offset); | 642 layer()->SetScrollOffset(scroll_offset); |
643 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta); | 643 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta); |
644 | 644 |
645 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled); | 645 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled); |
646 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset()); | 646 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset()); |
647 } | 647 } |
648 | 648 |
649 } // namespace | 649 } // namespace |
650 } // namespace cc | 650 } // namespace cc |
OLD | NEW |