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