Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(685)

Side by Side Diff: cc/layers/layer_impl_unittest.cc

Issue 23983047: Pinch/Zoom Infrastructure & Plumbing CL (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Remove content_bounds() usage, fix unit test. Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698