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 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
57 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { | 57 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { |
58 // | 58 // |
59 // This test checks that layerPropertyChanged() has the correct behavior. | 59 // This test checks that layerPropertyChanged() has the correct behavior. |
60 // | 60 // |
61 | 61 |
62 // The constructor on this will fake that we are on the correct thread. | 62 // The constructor on this will fake that we are on the correct thread. |
63 // Create a simple LayerImpl tree: | 63 // Create a simple LayerImpl tree: |
64 FakeImplProxy proxy; | 64 FakeImplProxy proxy; |
65 FakeLayerTreeHostImpl host_impl(&proxy); | 65 FakeLayerTreeHostImpl host_impl(&proxy); |
66 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); | 66 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); |
67 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); | 67 scoped_ptr<LayerImpl> root_clip = |
68 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2)); | 68 LayerImpl::Create(host_impl.active_tree(), 1); |
69 root_clip->AddChild(LayerImpl::Create(host_impl.active_tree(), 2)); | |
70 LayerImpl* root = root_clip->children()[0]; | |
71 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 3)); | |
69 LayerImpl* child = root->children()[0]; | 72 LayerImpl* child = root->children()[0]; |
70 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 3)); | 73 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 4)); |
71 LayerImpl* grand_child = child->children()[0]; | 74 LayerImpl* grand_child = child->children()[0]; |
72 | 75 |
73 root->SetScrollable(true); | 76 root->SetScrollable(root_clip->id()); |
74 | 77 |
75 // Adding children is an internal operation and should not mark layers as | 78 // Adding children is an internal operation and should not mark layers as |
76 // changed. | 79 // changed. |
77 EXPECT_FALSE(root->LayerPropertyChanged()); | 80 EXPECT_FALSE(root->LayerPropertyChanged()); |
78 EXPECT_FALSE(child->LayerPropertyChanged()); | 81 EXPECT_FALSE(child->LayerPropertyChanged()); |
79 EXPECT_FALSE(grand_child->LayerPropertyChanged()); | 82 EXPECT_FALSE(grand_child->LayerPropertyChanged()); |
80 | 83 |
81 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); | 84 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); |
82 float arbitrary_number = 0.352f; | 85 float arbitrary_number = 0.352f; |
83 gfx::Size arbitrary_size = gfx::Size(111, 222); | 86 gfx::Size arbitrary_size = gfx::Size(111, 222); |
84 gfx::Point arbitrary_point = gfx::Point(333, 444); | 87 gfx::Point arbitrary_point = gfx::Point(333, 444); |
85 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); | 88 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); |
86 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); | 89 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); |
87 gfx::RectF arbitrary_rect_f = | 90 gfx::RectF arbitrary_rect_f = |
88 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); | 91 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); |
89 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); | 92 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); |
90 gfx::Transform arbitrary_transform; | 93 gfx::Transform arbitrary_transform; |
91 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); | 94 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); |
92 FilterOperations arbitrary_filters; | 95 FilterOperations arbitrary_filters; |
93 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); | 96 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); |
94 | 97 |
95 // These properties are internal, and should not be considered "change" when | 98 // These properties are internal, and should not be considered "change" when |
96 // they are used. | 99 // they are used. |
97 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( | 100 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( |
98 root->set_update_rect(arbitrary_rect_f)); | 101 root->set_update_rect(arbitrary_rect_f)); |
99 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( | 102 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( |
100 root->SetMaxScrollOffset(arbitrary_vector2d)); | 103 root_clip->SetBounds(arbitrary_size)); |
101 | 104 |
102 // Changing these properties affects the entire subtree of layers. | 105 // Changing these properties affects the entire subtree of layers. |
103 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); | 106 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); |
104 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); | 107 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); |
105 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); | 108 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); |
106 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); | 109 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); |
107 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 110 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
108 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4))); | 111 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 5))); |
109 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); | 112 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); |
110 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); | 113 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); |
111 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 114 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
112 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5))); | 115 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 6))); |
113 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); | 116 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); |
114 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true)); | 117 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true)); |
115 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( | 118 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( |
116 root->SetDoubleSided(false)); // constructor initializes it to "true". | 119 root->SetDoubleSided(false)); // constructor initializes it to "true". |
117 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); | 120 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); |
118 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); | 121 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); |
119 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); | 122 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); |
120 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); | 123 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); |
121 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number)); | 124 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number)); |
122 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform)); | 125 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform)); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
175 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true)); | 178 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true)); |
176 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( | 179 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( |
177 root->SetSublayerTransform(arbitrary_transform)); | 180 root->SetSublayerTransform(arbitrary_transform)); |
178 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size)); | 181 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size)); |
179 } | 182 } |
180 | 183 |
181 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { | 184 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { |
182 FakeImplProxy proxy; | 185 FakeImplProxy proxy; |
183 FakeLayerTreeHostImpl host_impl(&proxy); | 186 FakeLayerTreeHostImpl host_impl(&proxy); |
184 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); | 187 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); |
185 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); | 188 scoped_ptr<LayerImpl> root_clip = |
186 root->SetScrollable(true); | 189 LayerImpl::Create(host_impl.active_tree(), 1); |
190 root_clip->AddChild(LayerImpl::Create(host_impl.active_tree(), 2)); | |
191 LayerImpl* root = root_clip->children()[0]; | |
192 root->SetScrollable(root_clip->id()); | |
187 | 193 |
188 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); | 194 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); |
189 float arbitrary_number = 0.352f; | 195 float arbitrary_number = 0.352f; |
190 gfx::Size arbitrary_size = gfx::Size(111, 222); | 196 gfx::Size arbitrary_size = gfx::Size(111, 222); |
191 gfx::Point arbitrary_point = gfx::Point(333, 444); | 197 gfx::Point arbitrary_point = gfx::Point(333, 444); |
192 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); | 198 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); |
193 gfx::Vector2d large_vector2d = gfx::Vector2d(1000, 1000); | 199 gfx::Size large_size = gfx::Size(1000, 1000); |
194 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); | 200 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); |
195 gfx::RectF arbitrary_rect_f = | 201 gfx::RectF arbitrary_rect_f = |
196 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); | 202 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); |
197 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); | 203 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); |
198 gfx::Transform arbitrary_transform; | 204 gfx::Transform arbitrary_transform; |
199 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); | 205 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); |
200 FilterOperations arbitrary_filters; | 206 FilterOperations arbitrary_filters; |
201 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); | 207 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); |
202 | 208 |
203 // Related filter functions. | 209 // Related filter functions. |
204 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 210 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
205 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 211 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
206 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); | 212 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); |
207 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); | 213 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); |
208 | 214 |
209 // Related scrolling functions. | 215 // Related scrolling functions. |
210 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d)); | 216 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(large_size)); |
211 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 217 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
212 root->SetMaxScrollOffset(large_vector2d)); | 218 root->SetBounds(large_size)); |
213 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d)); | 219 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d)); |
214 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d())); | 220 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d())); |
215 root->SetScrollDelta(gfx::Vector2d(0, 0)); | 221 root->SetScrollDelta(gfx::Vector2d(0, 0)); |
216 host_impl.ForcePrepareToDraw(); | 222 host_impl.ForcePrepareToDraw(); |
217 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d)); | 223 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d)); |
218 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 224 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
219 root->SetScrollDelta(arbitrary_vector2d)); | 225 root->SetScrollDelta(arbitrary_vector2d)); |
220 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( | 226 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( |
221 root->SetScrollOffset(arbitrary_vector2d)); | 227 root->SetScrollOffset(arbitrary_vector2d)); |
222 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( | 228 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
303 } | 309 } |
304 } | 310 } |
305 } | 311 } |
306 } | 312 } |
307 | 313 |
308 class LayerImplScrollTest : public testing::Test { | 314 class LayerImplScrollTest : public testing::Test { |
309 public: | 315 public: |
310 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) { | 316 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) { |
311 host_impl_.active_tree() | 317 host_impl_.active_tree() |
312 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_)); | 318 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_)); |
313 host_impl_.active_tree()->root_layer()->SetScrollable(true); | 319 host_impl_.active_tree()->root_layer()->AddChild( |
320 LayerImpl::Create(host_impl_.active_tree(), root_id_ + 1)); | |
321 layer()->SetScrollable(root_id_); | |
314 } | 322 } |
315 | 323 |
316 LayerImpl* layer() { return host_impl_.active_tree()->root_layer(); } | 324 LayerImpl* layer() { |
325 return host_impl_.active_tree()->root_layer()->children()[0]; | |
326 } | |
317 | 327 |
318 private: | 328 private: |
319 FakeImplProxy proxy_; | 329 FakeImplProxy proxy_; |
320 FakeLayerTreeHostImpl host_impl_; | 330 FakeLayerTreeHostImpl host_impl_; |
321 int root_id_; | 331 int root_id_; |
322 }; | 332 }; |
323 | 333 |
324 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { | 334 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { |
325 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll | 335 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll |
326 // offset is bounded by the range [0, max scroll offset]. | 336 // offset is bounded by the range [0, max scroll offset]. |
327 gfx::Vector2d max_scroll_offset(50, 80); | 337 gfx::Vector2d max_scroll_offset(50, 80); |
328 layer()->SetMaxScrollOffset(max_scroll_offset); | 338 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
enne (OOO)
2013/11/19 19:30:22
This is a little confusing. The max scroll offset
wjmaclean
2013/12/24 21:03:49
Done.
I moved the setup into the test class defin
| |
329 | 339 |
330 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); | 340 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); |
331 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 341 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
332 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 342 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
333 | 343 |
334 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); | 344 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); |
335 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); | 345 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); |
336 | 346 |
337 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); | 347 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); |
338 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 348 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
339 | 349 |
340 layer()->ScrollBy(gfx::Vector2dF(100, -100)); | 350 layer()->ScrollBy(gfx::Vector2dF(100, -100)); |
341 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); | 351 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); |
342 | 352 |
343 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); | 353 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); |
344 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); | 354 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); |
345 } | 355 } |
346 | 356 |
347 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { | 357 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { |
348 gfx::Vector2d max_scroll_offset(50, 80); | 358 gfx::Vector2d max_scroll_offset(50, 80); |
359 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); | |
349 gfx::Vector2d scroll_offset(10, 5); | 360 gfx::Vector2d scroll_offset(10, 5); |
350 layer()->SetMaxScrollOffset(max_scroll_offset); | |
351 layer()->SetScrollOffset(scroll_offset); | 361 layer()->SetScrollOffset(scroll_offset); |
352 | 362 |
353 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 363 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
354 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 364 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
355 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 365 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
356 | 366 |
357 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); | 367 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); |
358 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); | 368 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); |
359 | 369 |
360 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, | 370 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, |
(...skipping 24 matching lines...) Expand all Loading... | |
385 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} | 395 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} |
386 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} | 396 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} |
387 | 397 |
388 private: | 398 private: |
389 gfx::Vector2dF fixed_offset_; | 399 gfx::Vector2dF fixed_offset_; |
390 }; | 400 }; |
391 | 401 |
392 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { | 402 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { |
393 gfx::Vector2d max_scroll_offset(50, 80); | 403 gfx::Vector2d max_scroll_offset(50, 80); |
394 gfx::Vector2d scroll_offset(10, 5); | 404 gfx::Vector2d scroll_offset(10, 5); |
395 layer()->SetMaxScrollOffset(max_scroll_offset); | 405 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
396 layer()->SetScrollOffset(scroll_offset); | 406 layer()->SetScrollOffset(scroll_offset); |
397 | 407 |
398 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 408 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
399 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 409 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
400 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 410 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
401 | 411 |
402 ScrollDelegateIgnore delegate; | 412 ScrollDelegateIgnore delegate; |
403 gfx::Vector2dF fixed_offset(32, 12); | 413 gfx::Vector2dF fixed_offset(32, 12); |
404 delegate.set_fixed_offset(fixed_offset); | 414 delegate.set_fixed_offset(fixed_offset); |
405 layer()->SetScrollOffsetDelegate(&delegate); | 415 layer()->SetScrollOffsetDelegate(&delegate); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
437 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} | 447 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} |
438 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} | 448 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} |
439 | 449 |
440 private: | 450 private: |
441 gfx::Vector2dF current_offset_; | 451 gfx::Vector2dF current_offset_; |
442 }; | 452 }; |
443 | 453 |
444 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { | 454 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { |
445 gfx::Vector2d max_scroll_offset(50, 80); | 455 gfx::Vector2d max_scroll_offset(50, 80); |
446 gfx::Vector2d scroll_offset(10, 5); | 456 gfx::Vector2d scroll_offset(10, 5); |
447 layer()->SetMaxScrollOffset(max_scroll_offset); | 457 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
448 layer()->SetScrollOffset(scroll_offset); | 458 layer()->SetScrollOffset(scroll_offset); |
449 | 459 |
450 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 460 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
451 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 461 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
452 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); | 462 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); |
453 | 463 |
454 ScrollDelegateAccept delegate; | 464 ScrollDelegateAccept delegate; |
455 layer()->SetScrollOffsetDelegate(&delegate); | 465 layer()->SetScrollOffsetDelegate(&delegate); |
456 | 466 |
457 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); | 467 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); |
(...skipping 16 matching lines...) Expand all Loading... | |
474 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); | 484 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); |
475 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 485 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
476 } | 486 } |
477 | 487 |
478 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { | 488 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { |
479 gfx::Vector2d max_scroll_offset(50, 80); | 489 gfx::Vector2d max_scroll_offset(50, 80); |
480 gfx::Vector2d scroll_offset(10, 5); | 490 gfx::Vector2d scroll_offset(10, 5); |
481 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 491 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
482 gfx::Vector2d sent_scroll_delta(12, -3); | 492 gfx::Vector2d sent_scroll_delta(12, -3); |
483 | 493 |
484 layer()->SetMaxScrollOffset(max_scroll_offset); | 494 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
485 layer()->SetScrollOffset(scroll_offset); | 495 layer()->SetScrollOffset(scroll_offset); |
486 layer()->ScrollBy(scroll_delta); | 496 layer()->ScrollBy(scroll_delta); |
487 layer()->SetSentScrollDelta(sent_scroll_delta); | 497 layer()->SetSentScrollDelta(sent_scroll_delta); |
488 | 498 |
489 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 499 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
490 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); | 500 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); |
491 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 501 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
492 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 502 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
493 | 503 |
494 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 504 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
495 | 505 |
496 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 506 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
497 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); | 507 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); |
498 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 508 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
499 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 509 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
500 } | 510 } |
501 | 511 |
502 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { | 512 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { |
503 gfx::Vector2d max_scroll_offset(50, 80); | 513 gfx::Vector2d max_scroll_offset(50, 80); |
504 gfx::Vector2d scroll_offset(10, 5); | 514 gfx::Vector2d scroll_offset(10, 5); |
505 gfx::Vector2d sent_scroll_delta(12, -3); | 515 gfx::Vector2d sent_scroll_delta(12, -3); |
506 gfx::Vector2dF fixed_offset(32, 12); | 516 gfx::Vector2dF fixed_offset(32, 12); |
507 | 517 |
508 layer()->SetMaxScrollOffset(max_scroll_offset); | 518 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
509 layer()->SetScrollOffset(scroll_offset); | 519 layer()->SetScrollOffset(scroll_offset); |
510 ScrollDelegateIgnore delegate; | 520 ScrollDelegateIgnore delegate; |
511 delegate.set_fixed_offset(fixed_offset); | 521 delegate.set_fixed_offset(fixed_offset); |
512 layer()->SetScrollOffsetDelegate(&delegate); | 522 layer()->SetScrollOffsetDelegate(&delegate); |
513 layer()->SetSentScrollDelta(sent_scroll_delta); | 523 layer()->SetSentScrollDelta(sent_scroll_delta); |
514 | 524 |
515 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); | 525 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); |
516 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 526 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
517 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 527 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
518 | 528 |
519 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 529 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
520 | 530 |
521 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); | 531 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); |
522 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 532 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
523 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 533 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
524 } | 534 } |
525 | 535 |
526 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { | 536 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { |
527 gfx::Vector2d max_scroll_offset(50, 80); | 537 gfx::Vector2d max_scroll_offset(50, 80); |
528 gfx::Vector2d scroll_offset(10, 5); | 538 gfx::Vector2d scroll_offset(10, 5); |
529 gfx::Vector2d sent_scroll_delta(12, -3); | 539 gfx::Vector2d sent_scroll_delta(12, -3); |
530 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 540 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
531 | 541 |
532 layer()->SetMaxScrollOffset(max_scroll_offset); | 542 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
533 layer()->SetScrollOffset(scroll_offset); | 543 layer()->SetScrollOffset(scroll_offset); |
534 ScrollDelegateAccept delegate; | 544 ScrollDelegateAccept delegate; |
535 layer()->SetScrollOffsetDelegate(&delegate); | 545 layer()->SetScrollOffsetDelegate(&delegate); |
536 layer()->ScrollBy(scroll_delta); | 546 layer()->ScrollBy(scroll_delta); |
537 layer()->SetSentScrollDelta(sent_scroll_delta); | 547 layer()->SetSentScrollDelta(sent_scroll_delta); |
538 | 548 |
539 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 549 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
540 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); | 550 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); |
541 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); | 551 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); |
542 | 552 |
543 layer()->ApplySentScrollDeltasFromAbortedCommit(); | 553 layer()->ApplySentScrollDeltasFromAbortedCommit(); |
544 | 554 |
545 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); | 555 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); |
546 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); | 556 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); |
547 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); | 557 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); |
548 } | 558 } |
549 | 559 |
550 TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) { | 560 TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) { |
551 gfx::Vector2d max_scroll_offset(50, 80); | 561 gfx::Vector2d max_scroll_offset(50, 80); |
552 gfx::Vector2d scroll_offset(10, 5); | 562 gfx::Vector2d scroll_offset(10, 5); |
553 gfx::Vector2dF scroll_delta(20.5f, 8.5f); | 563 gfx::Vector2dF scroll_delta(20.5f, 8.5f); |
554 | 564 |
555 layer()->set_user_scrollable_vertical(false); | 565 layer()->set_user_scrollable_vertical(false); |
556 layer()->SetMaxScrollOffset(max_scroll_offset); | 566 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); |
557 layer()->SetScrollOffset(scroll_offset); | 567 layer()->SetScrollOffset(scroll_offset); |
558 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta); | 568 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta); |
559 | 569 |
560 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled); | 570 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled); |
561 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset()); | 571 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset()); |
562 } | 572 } |
563 | 573 |
564 } // namespace | 574 } // namespace |
565 } // namespace cc | 575 } // namespace cc |
OLD | NEW |