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/test/test_shared_bitmap_manager.h" 14 #include "cc/trees/layer_tree_impl.h" 15 #include "cc/trees/single_thread_proxy.h" 16 #include "testing/gmock/include/gmock/gmock.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 #include "third_party/skia/include/effects/SkBlurImageFilter.h" 19 20 namespace cc { 21 namespace { 22 23 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \ 24 root->ResetAllChangeTrackingForSubtree(); \ 25 code_to_test; \ 26 EXPECT_TRUE(root->needs_push_properties()); \ 27 EXPECT_FALSE(child->needs_push_properties()); \ 28 EXPECT_FALSE(grand_child->needs_push_properties()); \ 29 EXPECT_TRUE(root->LayerPropertyChanged()); \ 30 EXPECT_TRUE(child->LayerPropertyChanged()); \ 31 EXPECT_TRUE(grand_child->LayerPropertyChanged()); 32 33 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \ 34 root->ResetAllChangeTrackingForSubtree(); \ 35 code_to_test; \ 36 EXPECT_FALSE(root->needs_push_properties()); \ 37 EXPECT_FALSE(child->needs_push_properties()); \ 38 EXPECT_FALSE(grand_child->needs_push_properties()); \ 39 EXPECT_FALSE(root->LayerPropertyChanged()); \ 40 EXPECT_FALSE(child->LayerPropertyChanged()); \ 41 EXPECT_FALSE(grand_child->LayerPropertyChanged()); 42 43 #define EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( \ 44 code_to_test) \ 45 root->ResetAllChangeTrackingForSubtree(); \ 46 code_to_test; \ 47 EXPECT_TRUE(root->needs_push_properties()); \ 48 EXPECT_FALSE(child->needs_push_properties()); \ 49 EXPECT_FALSE(grand_child->needs_push_properties()); \ 50 EXPECT_FALSE(root->LayerPropertyChanged()); \ 51 EXPECT_FALSE(child->LayerPropertyChanged()); \ 52 EXPECT_FALSE(grand_child->LayerPropertyChanged()); 53 54 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \ 55 root->ResetAllChangeTrackingForSubtree(); \ 56 code_to_test; \ 57 EXPECT_TRUE(root->needs_push_properties()); \ 58 EXPECT_FALSE(child->needs_push_properties()); \ 59 EXPECT_FALSE(grand_child->needs_push_properties()); \ 60 EXPECT_TRUE(root->LayerPropertyChanged()); \ 61 EXPECT_FALSE(child->LayerPropertyChanged()); \ 62 EXPECT_FALSE(grand_child->LayerPropertyChanged()); 63 64 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \ 65 root->ResetAllChangeTrackingForSubtree(); \ 66 host_impl.ForcePrepareToDraw(); \ 67 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \ 68 code_to_test; \ 69 EXPECT_TRUE(host_impl.active_tree()->needs_update_draw_properties()); 70 71 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \ 72 root->ResetAllChangeTrackingForSubtree(); \ 73 host_impl.ForcePrepareToDraw(); \ 74 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \ 75 code_to_test; \ 76 EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); 77 78 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { 79 // 80 // This test checks that layerPropertyChanged() has the correct behavior. 81 // 82 83 // The constructor on this will fake that we are on the correct thread. 84 // Create a simple LayerImpl tree: 85 FakeImplProxy proxy; 86 TestSharedBitmapManager shared_bitmap_manager; 87 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); 88 EXPECT_TRUE(host_impl.InitializeRenderer( 89 FakeOutputSurface::Create3d().PassAs<OutputSurface>())); 90 scoped_ptr<LayerImpl> root_clip = 91 LayerImpl::Create(host_impl.active_tree(), 1); 92 scoped_ptr<LayerImpl> root_ptr = 93 LayerImpl::Create(host_impl.active_tree(), 2); 94 LayerImpl* root = root_ptr.get(); 95 root_clip->AddChild(root_ptr.Pass()); 96 scoped_ptr<LayerImpl> scroll_parent = 97 LayerImpl::Create(host_impl.active_tree(), 3); 98 LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 4).get(); 99 std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>(); 100 scroll_children->insert(scroll_child); 101 scroll_children->insert(root); 102 103 scoped_ptr<LayerImpl> clip_parent = 104 LayerImpl::Create(host_impl.active_tree(), 5); 105 LayerImpl* clip_child = LayerImpl::Create(host_impl.active_tree(), 6).get(); 106 std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>(); 107 clip_children->insert(clip_child); 108 clip_children->insert(root); 109 110 root->AddChild(LayerImpl::Create(host_impl.active_tree(), 7)); 111 LayerImpl* child = root->children()[0]; 112 child->AddChild(LayerImpl::Create(host_impl.active_tree(), 8)); 113 LayerImpl* grand_child = child->children()[0]; 114 115 root->SetScrollClipLayer(root_clip->id()); 116 117 // Adding children is an internal operation and should not mark layers as 118 // changed. 119 EXPECT_FALSE(root->LayerPropertyChanged()); 120 EXPECT_FALSE(child->LayerPropertyChanged()); 121 EXPECT_FALSE(grand_child->LayerPropertyChanged()); 122 123 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); 124 gfx::Point3F arbitrary_point_3f = gfx::Point3F(0.125f, 0.25f, 0.f); 125 float arbitrary_number = 0.352f; 126 gfx::Size arbitrary_size = gfx::Size(111, 222); 127 gfx::Point arbitrary_point = gfx::Point(333, 444); 128 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); 129 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); 130 gfx::RectF arbitrary_rect_f = 131 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); 132 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); 133 gfx::Transform arbitrary_transform; 134 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); 135 FilterOperations arbitrary_filters; 136 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); 137 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; 138 139 // These properties are internal, and should not be considered "change" when 140 // they are used. 141 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 142 root->SetUpdateRect(arbitrary_rect_f)); 143 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size)); 144 145 // Changing these properties affects the entire subtree of layers. 146 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 147 root->SetTransformOrigin(arbitrary_point_3f)); 148 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); 149 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); 150 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 151 root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 9))); 152 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true)); 153 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true)); 154 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 155 root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 10))); 156 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f)); 157 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetShouldFlattenTransform(false)); 158 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->Set3dSortingContextId(1)); 159 EXECUTE_AND_VERIFY_SUBTREE_CHANGED( 160 root->SetDoubleSided(false)); // constructor initializes it to "true". 161 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d)); 162 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d())); 163 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d)); 164 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true)); 165 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number)); 166 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode)); 167 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform)); 168 169 // Changing these properties only affects the layer itself. 170 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetContentBounds(arbitrary_size)); 171 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 172 root->SetContentsScale(arbitrary_number, arbitrary_number)); 173 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true)); 174 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 175 root->SetBackgroundColor(arbitrary_color)); 176 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED( 177 root->SetBackgroundFilters(arbitrary_filters)); 178 179 // Special case: check that SetBounds changes behavior depending on 180 // masksToBounds. 181 root->SetMasksToBounds(false); 182 EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246))); 183 root->SetMasksToBounds(true); 184 // Should be a different size than previous call, to ensure it marks tree 185 // changed. 186 EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size)); 187 188 // Changing this property does not cause the layer to be marked as changed 189 // but does cause the layer to need to push properties. 190 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 191 root->SetIsRootForIsolatedGroup(true)); 192 193 // Changing these properties should cause the layer to need to push properties 194 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 195 root->SetScrollParent(scroll_parent.get())); 196 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 197 root->SetScrollChildren(scroll_children)); 198 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 199 root->SetClipParent(clip_parent.get())); 200 EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( 201 root->SetClipChildren(clip_children)); 202 203 // After setting all these properties already, setting to the exact same 204 // values again should not cause any change. 205 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 206 root->SetTransformOrigin(arbitrary_point_3f)); 207 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true)); 208 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 209 root->SetPosition(arbitrary_point_f)); 210 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 211 root->SetShouldFlattenTransform(false)); 212 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->Set3dSortingContextId(1)); 213 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 214 root->SetTransform(arbitrary_transform)); 215 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 216 root->SetDoubleSided(false)); // constructor initializes it to "true". 217 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 218 root->SetScrollDelta(gfx::Vector2d())); 219 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 220 root->SetScrollOffset(arbitrary_vector2d)); 221 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 222 root->SetContentBounds(arbitrary_size)); 223 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 224 root->SetContentsScale(arbitrary_number, arbitrary_number)); 225 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true)); 226 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number)); 227 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 228 root->SetBlendMode(arbitrary_blend_mode)); 229 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 230 root->SetIsRootForIsolatedGroup(true)); 231 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true)); 232 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size)); 233 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 234 root->SetScrollParent(scroll_parent.get())); 235 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 236 root->SetScrollChildren(scroll_children)); 237 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 238 root->SetClipParent(clip_parent.get())); 239 EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE( 240 root->SetClipChildren(clip_children)); 241 } 242 243 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { 244 FakeImplProxy proxy; 245 TestSharedBitmapManager shared_bitmap_manager; 246 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); 247 EXPECT_TRUE(host_impl.InitializeRenderer( 248 FakeOutputSurface::Create3d().PassAs<OutputSurface>())); 249 host_impl.active_tree()->SetRootLayer( 250 LayerImpl::Create(host_impl.active_tree(), 1)); 251 LayerImpl* root = host_impl.active_tree()->root_layer(); 252 scoped_ptr<LayerImpl> layer_ptr = 253 LayerImpl::Create(host_impl.active_tree(), 2); 254 LayerImpl* layer = layer_ptr.get(); 255 root->AddChild(layer_ptr.Pass()); 256 layer->SetScrollClipLayer(root->id()); 257 DCHECK(host_impl.CanDraw()); 258 259 gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f); 260 float arbitrary_number = 0.352f; 261 gfx::Size arbitrary_size = gfx::Size(111, 222); 262 gfx::Point arbitrary_point = gfx::Point(333, 444); 263 gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222); 264 gfx::Size large_size = gfx::Size(1000, 1000); 265 gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size); 266 gfx::RectF arbitrary_rect_f = 267 gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f)); 268 SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); 269 gfx::Transform arbitrary_transform; 270 arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f); 271 FilterOperations arbitrary_filters; 272 arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); 273 SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode; 274 275 // Related filter functions. 276 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters)); 277 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters)); 278 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(FilterOperations())); 279 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters)); 280 281 // Related scrolling functions. 282 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size)); 283 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size)); 284 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d)); 285 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d())); 286 layer->SetScrollDelta(gfx::Vector2d(0, 0)); 287 host_impl.ForcePrepareToDraw(); 288 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 289 layer->SetScrollDelta(arbitrary_vector2d)); 290 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 291 layer->SetScrollDelta(arbitrary_vector2d)); 292 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 293 layer->SetScrollOffset(arbitrary_vector2d)); 294 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 295 layer->SetScrollOffset(arbitrary_vector2d)); 296 297 // Unrelated functions, always set to new values, always set needs update. 298 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 299 layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4))); 300 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true)); 301 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true)); 302 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 303 layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5))); 304 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f)); 305 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetShouldFlattenTransform(false)); 306 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1)); 307 308 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 309 layer->SetDoubleSided(false)); // constructor initializes it to "true". 310 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentBounds(arbitrary_size)); 311 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 312 layer->SetContentsScale(arbitrary_number, arbitrary_number)); 313 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true)); 314 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 315 layer->SetBackgroundColor(arbitrary_color)); 316 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 317 layer->SetBackgroundFilters(arbitrary_filters)); 318 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number)); 319 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( 320 layer->SetBlendMode(arbitrary_blend_mode)); 321 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetTransform(arbitrary_transform)); 322 VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size)); 323 324 // Unrelated functions, set to the same values, no needs update. 325 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 326 layer->SetIsRootForIsolatedGroup(true)); 327 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters)); 328 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true)); 329 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true)); 330 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f)); 331 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1)); 332 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 333 layer->SetDoubleSided(false)); // constructor initializes it to "true". 334 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 335 layer->SetContentBounds(arbitrary_size)); 336 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 337 layer->SetContentsScale(arbitrary_number, arbitrary_number)); 338 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true)); 339 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 340 layer->SetBackgroundColor(arbitrary_color)); 341 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 342 layer->SetBackgroundFilters(arbitrary_filters)); 343 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number)); 344 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 345 layer->SetBlendMode(arbitrary_blend_mode)); 346 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 347 layer->SetIsRootForIsolatedGroup(true)); 348 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES( 349 layer->SetTransform(arbitrary_transform)); 350 VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size)); 351 } 352 353 TEST(LayerImplTest, SafeOpaqueBackgroundColor) { 354 FakeImplProxy proxy; 355 TestSharedBitmapManager shared_bitmap_manager; 356 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); 357 EXPECT_TRUE(host_impl.InitializeRenderer( 358 FakeOutputSurface::Create3d().PassAs<OutputSurface>())); 359 scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1); 360 361 for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) { 362 for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) { 363 for (int host_opaque = 0; host_opaque < 2; ++host_opaque) { 364 layer->SetContentsOpaque(!!contents_opaque); 365 layer->SetBackgroundColor(layer_opaque ? SK_ColorRED 366 : SK_ColorTRANSPARENT); 367 host_impl.active_tree()->set_background_color( 368 host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT); 369 370 SkColor safe_color = layer->SafeOpaqueBackgroundColor(); 371 if (contents_opaque) { 372 EXPECT_EQ(SkColorGetA(safe_color), 255u) 373 << "Flags: " << contents_opaque << ", " << layer_opaque << ", " 374 << host_opaque << "\n"; 375 } else { 376 EXPECT_NE(SkColorGetA(safe_color), 255u) 377 << "Flags: " << contents_opaque << ", " << layer_opaque << ", " 378 << host_opaque << "\n"; 379 } 380 } 381 } 382 } 383 } 384 385 TEST(LayerImplTest, TransformInvertibility) { 386 FakeImplProxy proxy; 387 TestSharedBitmapManager shared_bitmap_manager; 388 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); 389 390 scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1); 391 EXPECT_TRUE(layer->transform().IsInvertible()); 392 EXPECT_TRUE(layer->transform_is_invertible()); 393 394 gfx::Transform transform; 395 transform.Scale3d( 396 SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0)); 397 layer->SetTransform(transform); 398 EXPECT_FALSE(layer->transform().IsInvertible()); 399 EXPECT_FALSE(layer->transform_is_invertible()); 400 401 transform.MakeIdentity(); 402 transform.ApplyPerspectiveDepth(SkDoubleToMScalar(100.0)); 403 transform.RotateAboutZAxis(75.0); 404 transform.RotateAboutXAxis(32.2); 405 transform.RotateAboutZAxis(-75.0); 406 transform.Translate3d(SkDoubleToMScalar(50.5), 407 SkDoubleToMScalar(42.42), 408 SkDoubleToMScalar(-100.25)); 409 410 layer->SetTransform(transform); 411 EXPECT_TRUE(layer->transform().IsInvertible()); 412 EXPECT_TRUE(layer->transform_is_invertible()); 413 } 414 415 class LayerImplScrollTest : public testing::Test { 416 public: 417 LayerImplScrollTest() 418 : host_impl_(&proxy_, &shared_bitmap_manager_), root_id_(7) { 419 host_impl_.active_tree()->SetRootLayer( 420 LayerImpl::Create(host_impl_.active_tree(), root_id_)); 421 host_impl_.active_tree()->root_layer()->AddChild( 422 LayerImpl::Create(host_impl_.active_tree(), root_id_ + 1)); 423 layer()->SetScrollClipLayer(root_id_); 424 // Set the max scroll offset by noting that the root layer has bounds (1,1), 425 // thus whatever bounds are set for the layer will be the max scroll 426 // offset plus 1 in each direction. 427 host_impl_.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1)); 428 gfx::Vector2d max_scroll_offset(51, 81); 429 layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y())); 430 } 431 432 LayerImpl* layer() { 433 return host_impl_.active_tree()->root_layer()->children()[0]; 434 } 435 436 private: 437 FakeImplProxy proxy_; 438 TestSharedBitmapManager shared_bitmap_manager_; 439 FakeLayerTreeHostImpl host_impl_; 440 int root_id_; 441 }; 442 443 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) { 444 // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll 445 // offset is bounded by the range [0, max scroll offset]. 446 447 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset()); 448 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 449 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 450 451 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 452 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 453 454 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); 455 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 456 457 layer()->ScrollBy(gfx::Vector2dF(100, -100)); 458 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); 459 460 EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset()); 461 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset()); 462 } 463 464 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) { 465 gfx::Vector2d scroll_offset(10, 5); 466 layer()->SetScrollOffset(scroll_offset); 467 468 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 469 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 470 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 471 472 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 473 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 474 475 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, 476 layer()->TotalScrollOffset()); 477 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 478 479 layer()->ScrollBy(gfx::Vector2dF(100, -100)); 480 EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset()); 481 482 EXPECT_VECTOR_EQ(layer()->ScrollDelta() + scroll_offset, 483 layer()->TotalScrollOffset()); 484 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 485 } 486 487 class ScrollDelegateIgnore : public LayerImpl::ScrollOffsetDelegate { 488 public: 489 virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_value) OVERRIDE {} 490 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE { 491 return fixed_offset_; 492 } 493 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } 494 495 void set_fixed_offset(const gfx::Vector2dF& fixed_offset) { 496 fixed_offset_ = fixed_offset; 497 } 498 499 private: 500 gfx::Vector2dF fixed_offset_; 501 }; 502 503 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) { 504 gfx::Vector2d scroll_offset(10, 5); 505 layer()->SetScrollOffset(scroll_offset); 506 507 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 508 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 509 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 510 511 ScrollDelegateIgnore delegate; 512 gfx::Vector2dF fixed_offset(32, 12); 513 delegate.set_fixed_offset(fixed_offset); 514 layer()->SetScrollOffsetDelegate(&delegate); 515 516 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 517 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 518 519 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 520 521 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 522 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 523 524 layer()->SetScrollOffsetDelegate(NULL); 525 526 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 527 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 528 529 gfx::Vector2dF scroll_delta(1, 1); 530 layer()->ScrollBy(scroll_delta); 531 532 EXPECT_VECTOR_EQ(fixed_offset + scroll_delta, layer()->TotalScrollOffset()); 533 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 534 } 535 536 class ScrollDelegateAccept : public LayerImpl::ScrollOffsetDelegate { 537 public: 538 virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_value) OVERRIDE { 539 current_offset_ = new_value; 540 } 541 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE { 542 return current_offset_; 543 } 544 virtual bool IsExternalFlingActive() const OVERRIDE { return false; } 545 546 private: 547 gfx::Vector2dF current_offset_; 548 }; 549 550 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) { 551 gfx::Vector2d scroll_offset(10, 5); 552 layer()->SetScrollOffset(scroll_offset); 553 554 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 555 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 556 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 557 558 ScrollDelegateAccept delegate; 559 layer()->SetScrollOffsetDelegate(&delegate); 560 561 EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset()); 562 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 563 EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta()); 564 565 layer()->ScrollBy(gfx::Vector2dF(-100, 100)); 566 567 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 568 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 569 570 layer()->SetScrollOffsetDelegate(NULL); 571 572 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset()); 573 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 574 575 gfx::Vector2dF scroll_delta(1, 1); 576 layer()->ScrollBy(scroll_delta); 577 578 EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset()); 579 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 580 } 581 582 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) { 583 gfx::Vector2d scroll_offset(10, 5); 584 gfx::Vector2dF scroll_delta(20.5f, 8.5f); 585 gfx::Vector2d sent_scroll_delta(12, -3); 586 587 layer()->SetScrollOffset(scroll_offset); 588 layer()->ScrollBy(scroll_delta); 589 layer()->SetSentScrollDelta(sent_scroll_delta); 590 591 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 592 EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta()); 593 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 594 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 595 596 layer()->ApplySentScrollDeltasFromAbortedCommit(); 597 598 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 599 EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta()); 600 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 601 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 602 } 603 604 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) { 605 gfx::Vector2d scroll_offset(10, 5); 606 gfx::Vector2d sent_scroll_delta(12, -3); 607 gfx::Vector2dF fixed_offset(32, 12); 608 609 layer()->SetScrollOffset(scroll_offset); 610 ScrollDelegateIgnore delegate; 611 delegate.set_fixed_offset(fixed_offset); 612 layer()->SetScrollOffsetDelegate(&delegate); 613 layer()->SetSentScrollDelta(sent_scroll_delta); 614 615 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 616 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 617 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 618 619 layer()->ApplySentScrollDeltasFromAbortedCommit(); 620 621 EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset()); 622 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 623 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 624 } 625 626 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) { 627 gfx::Vector2d scroll_offset(10, 5); 628 gfx::Vector2d sent_scroll_delta(12, -3); 629 gfx::Vector2dF scroll_delta(20.5f, 8.5f); 630 631 layer()->SetScrollOffset(scroll_offset); 632 ScrollDelegateAccept delegate; 633 layer()->SetScrollOffsetDelegate(&delegate); 634 layer()->ScrollBy(scroll_delta); 635 layer()->SetSentScrollDelta(sent_scroll_delta); 636 637 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 638 EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset()); 639 EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta()); 640 641 layer()->ApplySentScrollDeltasFromAbortedCommit(); 642 643 EXPECT_VECTOR_EQ(scroll_offset + scroll_delta, layer()->TotalScrollOffset()); 644 EXPECT_VECTOR_EQ(scroll_offset + sent_scroll_delta, layer()->scroll_offset()); 645 EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta()); 646 } 647 648 // The user-scrollability breaks for zoomed-in pages. So disable this. 649 // http://crbug.com/322223 650 TEST_F(LayerImplScrollTest, DISABLED_ScrollUserUnscrollableLayer) { 651 gfx::Vector2d scroll_offset(10, 5); 652 gfx::Vector2dF scroll_delta(20.5f, 8.5f); 653 654 layer()->set_user_scrollable_vertical(false); 655 layer()->SetScrollOffset(scroll_offset); 656 gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta); 657 658 EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled); 659 EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset()); 660 } 661 662 } // namespace 663 } // namespace cc 664
