1 // Copyright 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "cc/layers/layer_impl.h" 6 7 #include "cc/output/filter_operation.h" 8 #include "cc/output/filter_operations.h" 9 #include "cc/test/fake_impl_proxy.h" 10 #include "cc/test/fake_layer_tree_host_impl.h" 11 #include "cc/test/fake_output_surface.h" 12 #include "cc/test/geometry_test_utils.h" 13 #include "cc/trees/layer_tree_impl.h" 14 #include "cc/trees/single_thread_proxy.h" 15 #include "testing/gmock/include/gmock/gmock.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 #include "third_party/skia/include/effects/SkBlurImageFilter.h" 18 19 namespace cc { 20 namespace { 21 22 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \ 23 root->ResetAllChangeTrackingForSubtree(); \ 24 code_to_test; \ 25 EXPECT_TRUE(root->LayerPropertyChanged()); \ 26 EXPECT_TRUE(child->LayerPropertyChanged()); \ 27 EXPECT_TRUE(grand_child->LayerPropertyChanged()); \ 28 EXPECT_FALSE(root->LayerSurfacePropertyChanged()) 29 30 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \ 31 root->ResetAllChangeTrackingForSubtree(); \ 32 code_to_test; \ 33 EXPECT_FALSE(root->LayerPropertyChanged()); \ 34 EXPECT_FALSE(child->LayerPropertyChanged()); \ 35 EXPECT_FALSE(grand_child->LayerPropertyChanged()); \ 36 EXPECT_FALSE(root->LayerSurfacePropertyChanged()) 37 38 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \ 39 root->ResetAllChangeTrackingForSubtree(); \ 40 code_to_test; \ 41 EXPECT_TRUE(root->LayerPropertyChanged()); \ 42 EXPECT_FALSE(child->LayerPropertyChanged()); \ 43 EXPECT_FALSE(grand_child->LayerPropertyChanged()); \ 44 EXPECT_FALSE(root->LayerSurfacePropertyChanged()) 45 46 #define EXECUTE_AND_VERIFY_ONLY_SURFACE_CHANGED(code_to_test) \ 47 root->ResetAllChangeTrackingForSubtree(); \ 48 code_to_test; \ 49 EXPECT_FALSE(root->LayerPropertyChanged()); \ 50 EXPECT_FALSE(child->LayerPropertyChanged()); \ 51 EXPECT_FALSE(grand_child->LayerPropertyChanged()); \ 52 EXPECT_TRUE(root->LayerSurfacePropertyChanged()) 53 54 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \ 55 root->ResetAllChangeTrackingForSubtree(); \ 56 host_impl.ForcePrepareToDraw(); \ 57 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \ 58 code_to_test; \ 59 EXPECT_TRUE(host_impl.active_tree()->needs_update_draw_properties()); 60 61 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \ 62 root->ResetAllChangeTrackingForSubtree(); \ 63 host_impl.ForcePrepareToDraw(); \ 64 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \ 65 code_to_test; \ 66 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); 67 68 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { 69 // 70 // This test checks that layerPropertyChanged() has the correct behavior. 71 // 72 73 // The constructor on this will fake that we are on the correct thread. 74 // Create a simple LayerImpl tree: 75 FakeImplProxy proxy; 76 FakeLayerTreeHostImpl host_impl(&proxy); 77 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); 78 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); 79 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2)); 80 LayerImpl* child = root->children()[0]; 81 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 3)); 82 LayerImpl* grand_child = child->children()[0]; 83 84 root->SetScrollable(true); 85 86 // Adding children is an internal operation and should not mark layers as 87 // changed. 88 EXPECT_FALSE(root->LayerPropertyChanged()); 89 EXPECT_FALSE(child->LayerPropertyChanged()); 90 EXPECT_FALSE(grand_child->LayerPropertyChanged()); 91 92 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); 93 float arbitrary_number = 0.352f; 94 gfx::Size arbitrary_size = gfx::Size(111, 222); 95 gfx::Point arbitrary_point = gfx::Point(333, 444); 96 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); 97 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); 98 gfx::RectF arbitrary_rect_f = 99 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); 100 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); 101 gfx::Transform arbitrary_transform; 102 arbitrary_transform.Scale3d(0.1, 0.2, 0.3); 103 FilterOperations arbitrary_filters; 104 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); 105 skia::RefPtr<SkImageFilter> arbitrary_filter = 106 skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); 107 108 // These properties are internal, and should not be considered "change" when 109 // they are used. 110 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 111 root->set_update_rect(arbitrary_rect_f)); 112 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 113 root->SetMaxScrollOffset(arbitrary_vector2d)); 114 115 // Changing these properties affects the entire subtree of layers. 116 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); 117 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); 118 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); 119 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); 120 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilter(arbitrary_filter)); 121 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 122 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4))); 123 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); 124 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); 125 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 126 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5))); 127 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); 128 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true)); 129 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 130 root->SetDoubleSided(false)); // constructor initializes it to "true". 131 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); 132 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); 133 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); 134 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); 135 136 // Changing these properties only affects the layer itself. 137 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetContentBounds(arbitrary_size)); 138 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 139 root->SetContentsScale(arbitrary_number, arbitrary_number)); 140 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true)); 141 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 142 root->SetBackgroundColor(arbitrary_color)); 143 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 144 root->SetBackgroundFilters(arbitrary_filters)); 145 146 // Changing these properties only affects how render surface is drawn 147 EXECUTE_AND_VERIFY_ONLY_SURFACE_CHANGED(root->SetOpacity(arbitrary_number)); 148 EXECUTE_AND_VERIFY_ONLY_SURFACE_CHANGED( 149 root->SetTransform(arbitrary_transform)); 150 151 // Special case: check that sublayer transform changes all layer's 152 // descendants, but not the layer itself. 153 root->ResetAllChangeTrackingForSubtree(); 154 root->SetSublayerTransform(arbitrary_transform); 155 EXPECT_FALSE(root->LayerPropertyChanged()); 156 EXPECT_TRUE(child->LayerPropertyChanged()); 157 EXPECT_TRUE(grand_child->LayerPropertyChanged()); 158 159 // Special case: check that SetBounds changes behavior depending on 160 // masksToBounds. 161 root->SetMasksToBounds(false); 162 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246))); 163 root->SetMasksToBounds(true); 164 // Should be a different size than previous call, to ensure it marks tree 165 // changed. 166 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size)); 167 168 // After setting all these properties already, setting to the exact same 169 // values again should not cause any change. 170 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 171 root->SetAnchorPoint(arbitrary_point_f)); 172 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 173 root->SetAnchorPointZ(arbitrary_number)); 174 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true)); 175 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 176 root->SetPosition(arbitrary_point_f)); 177 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetPreserves3d(true)); 178 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 179 root->SetTransform(arbitrary_transform)); 180 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 181 root->SetDoubleSided(false)); // constructor initializes it to "true". 182 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 183 root->SetScrollDelta(gfx::Vector2d())); 184 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 185 root->SetScrollOffset(arbitrary_vector2d)); 186 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 187 root->SetContentBounds(arbitrary_size)); 188 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 189 root->SetContentsScale(arbitrary_number, arbitrary_number)); 190 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true)); 191 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number)); 192 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true)); 193 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 194 root->SetSublayerTransform(arbitrary_transform)); 195 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size)); 196 } 197 198 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { 199 FakeImplProxy proxy; 200 FakeLayerTreeHostImpl host_impl(&proxy); 201 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); 202 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); 203 root->SetScrollable(true); 204 205 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); 206 float arbitrary_number = 0.352f; 207 gfx::Size arbitrary_size = gfx::Size(111, 222); 208 gfx::Point arbitrary_point = gfx::Point(333, 444); 209 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); 210 gfx::Vector2d large_vector2d = gfx::Vector2d(1000, 1000); 211 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); 212 gfx::RectF arbitrary_rect_f = 213 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); 214 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); 215 gfx::Transform arbitrary_transform; 216 arbitrary_transform.Scale3d(0.1, 0.2, 0.3); 217 FilterOperations arbitrary_filters; 218 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); 219 skia::RefPtr<SkImageFilter> arbitrary_filter = 220 skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); 221 222 // Related filter functions. 223 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); 224 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); 225 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); 226 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilter(arbitrary_filter)); 227 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilter(arbitrary_filter)); 228 229 // Related scrolling functions. 230 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d)); 231 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 232 root->SetMaxScrollOffset(large_vector2d)); 233 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d)); 234 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d())); 235 root->SetScrollDelta(gfx::Vector2d(0, 0)); 236 host_impl.ForcePrepareToDraw(); 237 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d)); 238 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 239 root->SetScrollDelta(arbitrary_vector2d)); 240 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 241 root->SetScrollOffset(arbitrary_vector2d)); 242 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 243 root->SetScrollOffset(arbitrary_vector2d)); 244 245 // Unrelated functions, always set to new values, always set needs update. 246 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetAnchorPointZ(arbitrary_number)); 247 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 248 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4))); 249 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true)); 250 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true)); 251 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 252 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5))); 253 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f)); 254 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true)); 255 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 256 root->SetDoubleSided(false)); // constructor initializes it to "true". 257 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentBounds(arbitrary_size)); 258 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 259 root->SetContentsScale(arbitrary_number, arbitrary_number)); 260 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true)); 261 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 262 root->SetBackgroundColor(arbitrary_color)); 263 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 264 root->SetBackgroundFilters(arbitrary_filters)); 265 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number)); 266 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetTransform(arbitrary_transform)); 267 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 268 root->SetSublayerTransform(arbitrary_transform)); 269 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size)); 270 271 // Unrelated functions, set to the same values, no needs update. 272 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 273 root->SetAnchorPointZ(arbitrary_number)); 274 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilter(arbitrary_filter)); 275 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true)); 276 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true)); 277 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f)); 278 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true)); 279 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 280 root->SetDoubleSided(false)); // constructor initializes it to "true". 281 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 282 root->SetContentBounds(arbitrary_size)); 283 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 284 root->SetContentsScale(arbitrary_number, arbitrary_number)); 285 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true)); 286 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 287 root->SetBackgroundColor(arbitrary_color)); 288 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 289 root->SetBackgroundFilters(arbitrary_filters)); 290 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number)); 291 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 292 root->SetTransform(arbitrary_transform)); 293 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 294 root->SetSublayerTransform(arbitrary_transform)); 295 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size)); 296 } 297 298 TEST(LayerImplTest, SafeOpaqueBackgroundColor) { 299 FakeImplProxy proxy; 300 FakeLayerTreeHostImpl host_impl(&proxy); 301 EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface())); 302 scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1); 303 304 for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) { 305 for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) { 306 for (int host_opaque = 0; host_opaque < 2; ++host_opaque) { 307 layer->SetContentsOpaque(!!contents_opaque); 308 layer->SetBackgroundColor(layer_opaque ? SK_ColorRED 309 : SK_ColorTRANSPARENT); 310 host_impl.active_tree()->set_background_color( 311 host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT); 312 313 SkColor safe_color = layer->SafeOpaqueBackgroundColor(); 314 if (contents_opaque) { 315 EXPECT_EQ(SkColorGetA(safe_color), 255u) 316 << "Flags: " << contents_opaque << ", " << layer_opaque << ", " 317 << host_opaque << "\n"; 318 } else { 319 EXPECT_NE(SkColorGetA(safe_color), 255u) 320 << "Flags: " << contents_opaque << ", " << layer_opaque << ", " 321 << host_opaque << "\n"; 322 } 323 } 324 } 325 } 326 } 327 328 class LayerImplScrollTest : public testing::Test { 329 public: 330 LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) { 331 host_impl_.active_tree() 332 ->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_)); 333 host_impl_.active_tree()->root_layer()->SetScrollable(true); 334 } 335 336 LayerImpl* layer() { return host_impl_.active_tree()->root_layer(); } 337 338 private: 339 FakeImplProxy proxy_; 340 FakeLayerTreeHostImpl host_impl_; 341 int root_id_; 342 }; 343 344 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { 345 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll 346 // offset is bounded by the range [0, max scroll offset]. 347 gfx::Vector2d max_scroll_offset(50, 80); 348 layer()->SetMaxScrollOffset(max_scroll_offset); 349 350 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); 351 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 352 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 353 354 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 355 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 356 357 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); 358 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 359 360 layer()->ScrollBy(gfx::Vector2dF(100, -100)); 361 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); 362 363 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); 364 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 365 } 366 367 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { 368 gfx::Vector2d max_scroll_offset(50, 80); 369 gfx::Vector2d scroll_offset(10, 5); 370 layer()->SetMaxScrollOffset(max_scroll_offset); 371 layer()->SetScrollOffset(scroll_offset); 372 373 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 374 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 375 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 376 377 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 378 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 379 380 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, 381 layer()->TotalScrollOffset()); 382 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 383 384 layer()->ScrollBy(gfx::Vector2dF(100, -100)); 385 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); 386 387 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, 388 layer()->TotalScrollOffset()); 389 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 390 } 391 392 class ScrollDelegateIgnore : public LayerScrollOffsetDelegate { 393 public: 394 virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {} 395 virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE {} 396 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE { 397 return fixed_offset_; 398 } 399 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } 400 401 void set_fixed_offset(gfx::Vector2dF fixed_offset) { 402 fixed_offset_ = fixed_offset; 403 } 404 405 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} 406 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} 407 408 private: 409 gfx::Vector2dF fixed_offset_; 410 }; 411 412 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { 413 gfx::Vector2d max_scroll_offset(50, 80); 414 gfx::Vector2d scroll_offset(10, 5); 415 layer()->SetMaxScrollOffset(max_scroll_offset); 416 layer()->SetScrollOffset(scroll_offset); 417 418 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 419 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 420 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 421 422 ScrollDelegateIgnore delegate; 423 gfx::Vector2dF fixed_offset(32, 12); 424 delegate.set_fixed_offset(fixed_offset); 425 layer()->SetScrollOffsetDelegate(&delegate); 426 427 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 428 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 429 430 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 431 432 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 433 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 434 435 layer()->SetScrollOffsetDelegate(NULL); 436 437 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 438 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 439 440 gfx::Vector2dF scroll_delta(1, 1); 441 layer()->ScrollBy(scroll_delta); 442 443 EXPECT_VECTOR_EQ(fixed_offset + scroll_delta, layer()->TotalScrollOffset()); 444 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 445 } 446 447 class ScrollDelegateAccept : public LayerScrollOffsetDelegate { 448 public: 449 virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {} 450 virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE { 451 current_offset_ = new_value; 452 } 453 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE { 454 return current_offset_; 455 } 456 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } 457 virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {} 458 virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {} 459 460 private: 461 gfx::Vector2dF current_offset_; 462 }; 463 464 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { 465 gfx::Vector2d max_scroll_offset(50, 80); 466 gfx::Vector2d scroll_offset(10, 5); 467 layer()->SetMaxScrollOffset(max_scroll_offset); 468 layer()->SetScrollOffset(scroll_offset); 469 470 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 471 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 472 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 473 474 ScrollDelegateAccept delegate; 475 layer()->SetScrollOffsetDelegate(&delegate); 476 477 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 478 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 479 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 480 481 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 482 483 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 484 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 485 486 layer()->SetScrollOffsetDelegate(NULL); 487 488 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 489 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 490 491 gfx::Vector2dF scroll_delta(1, 1); 492 layer()->ScrollBy(scroll_delta); 493 494 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); 495 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 496 } 497 498 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { 499 gfx::Vector2d max_scroll_offset(50, 80); 500 gfx::Vector2d scroll_offset(10, 5); 501 gfx::Vector2dF scroll_delta(20.5f, 8.5f); 502 gfx::Vector2d sent_scroll_delta(12, -3); 503 504 layer()->SetMaxScrollOffset(max_scroll_offset); 505 layer()->SetScrollOffset(scroll_offset); 506 layer()->ScrollBy(scroll_delta); 507 layer()->SetSentScrollDelta(sent_scroll_delta); 508 509 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 510 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); 511 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 512 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 513 514 layer()->ApplySentScrollDeltas(); 515 516 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 517 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); 518 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 519 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 520 } 521 522 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { 523 gfx::Vector2d max_scroll_offset(50, 80); 524 gfx::Vector2d scroll_offset(10, 5); 525 gfx::Vector2d sent_scroll_delta(12, -3); 526 gfx::Vector2dF fixed_offset(32, 12); 527 528 layer()->SetMaxScrollOffset(max_scroll_offset); 529 layer()->SetScrollOffset(scroll_offset); 530 ScrollDelegateIgnore delegate; 531 delegate.set_fixed_offset(fixed_offset); 532 layer()->SetScrollOffsetDelegate(&delegate); 533 layer()->SetSentScrollDelta(sent_scroll_delta); 534 535 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 536 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 537 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 538 539 layer()->ApplySentScrollDeltas(); 540 541 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 542 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 543 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 544 } 545 546 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { 547 gfx::Vector2d max_scroll_offset(50, 80); 548 gfx::Vector2d scroll_offset(10, 5); 549 gfx::Vector2d sent_scroll_delta(12, -3); 550 gfx::Vector2dF scroll_delta(20.5f, 8.5f); 551 552 layer()->SetMaxScrollOffset(max_scroll_offset); 553 layer()->SetScrollOffset(scroll_offset); 554 ScrollDelegateAccept delegate; 555 layer()->SetScrollOffsetDelegate(&delegate); 556 layer()->ScrollBy(scroll_delta); 557 layer()->SetSentScrollDelta(sent_scroll_delta); 558 559 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 560 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 561 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 562 563 layer()->ApplySentScrollDeltas(); 564 565 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 566 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 567 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 568 } 569 570 } // namespace 571 } // namespace cc 572
