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/trees/layer_tree_host_common.h" | 5 #include "cc/trees/layer_tree_host_common.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <set> | 8 #include <set> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
164 child->SetOpacity(0.f); | 164 child->SetOpacity(0.f); |
165 SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(), | 165 SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(), |
166 gfx::PointF(10, 10), gfx::Size(100, 100), true, | 166 gfx::PointF(10, 10), gfx::Size(100, 100), true, |
167 false, false); | 167 false, false); |
168 grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100)); | 168 grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100)); |
169 | 169 |
170 ExecuteCalculateDrawProperties(parent); | 170 ExecuteCalculateDrawProperties(parent); |
171 | 171 |
172 // Check that we've computed draw properties for the subtree rooted at | 172 // Check that we've computed draw properties for the subtree rooted at |
173 // |child|. | 173 // |child|. |
174 EXPECT_FALSE(child->draw_transform().IsIdentity()); | 174 EXPECT_FALSE(child->draw_properties().target_space_transform.IsIdentity()); |
175 EXPECT_FALSE(grand_child->draw_transform().IsIdentity()); | 175 EXPECT_FALSE( |
| 176 grand_child->draw_properties().target_space_transform.IsIdentity()); |
176 } | 177 } |
177 | 178 |
178 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) { | 179 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) { |
179 gfx::Transform identity_matrix; | 180 gfx::Transform identity_matrix; |
180 scoped_refptr<Layer> layer = Layer::Create(layer_settings()); | 181 scoped_refptr<Layer> layer = Layer::Create(layer_settings()); |
181 | 182 |
182 scoped_refptr<Layer> root = Layer::Create(layer_settings()); | 183 scoped_refptr<Layer> root = Layer::Create(layer_settings()); |
183 SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(), | 184 SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(), |
184 gfx::PointF(), gfx::Size(1, 2), true, false); | 185 gfx::PointF(), gfx::Size(1, 2), true, false); |
185 root->AddChild(layer); | 186 root->AddChild(layer); |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
329 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); | 330 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); |
330 gfx::Transform expected_transform = identity_matrix; | 331 gfx::Transform expected_transform = identity_matrix; |
331 gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta; | 332 gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta; |
332 expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() * | 333 expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() * |
333 kPageScale * kDeviceScale), | 334 kPageScale * kDeviceScale), |
334 MathUtil::Round(sub_layer_screen_position.y() * | 335 MathUtil::Round(sub_layer_screen_position.y() * |
335 kPageScale * kDeviceScale)); | 336 kPageScale * kDeviceScale)); |
336 expected_transform.Scale(kPageScale * kDeviceScale, | 337 expected_transform.Scale(kPageScale * kDeviceScale, |
337 kPageScale * kDeviceScale); | 338 kPageScale * kDeviceScale); |
338 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, | 339 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, |
339 sublayer->draw_transform()); | 340 sublayer->DrawTransform()); |
340 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, | 341 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, |
341 sublayer->screen_space_transform()); | 342 sublayer->screen_space_transform()); |
342 | 343 |
343 gfx::Transform arbitrary_translate; | 344 gfx::Transform arbitrary_translate; |
344 const float kTranslateX = 10.6f; | 345 const float kTranslateX = 10.6f; |
345 const float kTranslateY = 20.6f; | 346 const float kTranslateY = 20.6f; |
346 arbitrary_translate.Translate(kTranslateX, kTranslateY); | 347 arbitrary_translate.Translate(kTranslateX, kTranslateY); |
347 SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate, | 348 SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate, |
348 gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20), | 349 gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20), |
349 true, false, false); | 350 true, false, false); |
350 root->layer_tree_impl()->property_trees()->needs_rebuild = true; | 351 root->layer_tree_impl()->property_trees()->needs_rebuild = true; |
351 ExecuteCalculateDrawProperties( | 352 ExecuteCalculateDrawProperties( |
352 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); | 353 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); |
353 expected_transform.MakeIdentity(); | 354 expected_transform.MakeIdentity(); |
354 expected_transform.Translate( | 355 expected_transform.Translate( |
355 MathUtil::Round(kTranslateX * kPageScale * kDeviceScale + | 356 MathUtil::Round(kTranslateX * kPageScale * kDeviceScale + |
356 sub_layer_screen_position.x() * kPageScale * | 357 sub_layer_screen_position.x() * kPageScale * |
357 kDeviceScale), | 358 kDeviceScale), |
358 MathUtil::Round(kTranslateY * kPageScale * kDeviceScale + | 359 MathUtil::Round(kTranslateY * kPageScale * kDeviceScale + |
359 sub_layer_screen_position.y() * kPageScale * | 360 sub_layer_screen_position.y() * kPageScale * |
360 kDeviceScale)); | 361 kDeviceScale)); |
361 expected_transform.Scale(kPageScale * kDeviceScale, | 362 expected_transform.Scale(kPageScale * kDeviceScale, |
362 kPageScale * kDeviceScale); | 363 kPageScale * kDeviceScale); |
363 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, | 364 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, |
364 sublayer->draw_transform()); | 365 sublayer->DrawTransform()); |
365 } | 366 } |
366 | 367 |
367 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) { | 368 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) { |
368 gfx::Transform identity_matrix; | 369 gfx::Transform identity_matrix; |
369 scoped_refptr<Layer> root = Layer::Create(layer_settings()); | 370 scoped_refptr<Layer> root = Layer::Create(layer_settings()); |
370 scoped_refptr<Layer> parent = Layer::Create(layer_settings()); | 371 scoped_refptr<Layer> parent = Layer::Create(layer_settings()); |
371 scoped_refptr<Layer> child = Layer::Create(layer_settings()); | 372 scoped_refptr<Layer> child = Layer::Create(layer_settings()); |
372 scoped_refptr<Layer> grand_child = Layer::Create(layer_settings()); | 373 scoped_refptr<Layer> grand_child = Layer::Create(layer_settings()); |
373 root->AddChild(parent); | 374 root->AddChild(parent); |
374 parent->AddChild(child); | 375 parent->AddChild(child); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
504 false); | 505 false); |
505 ExecuteCalculateDrawProperties(root); | 506 ExecuteCalculateDrawProperties(root); |
506 | 507 |
507 // Render surface should have been created now. | 508 // Render surface should have been created now. |
508 ASSERT_TRUE(child->render_surface()); | 509 ASSERT_TRUE(child->render_surface()); |
509 ASSERT_EQ(child, child->render_target()); | 510 ASSERT_EQ(child, child->render_target()); |
510 | 511 |
511 // The child layer's draw transform should refer to its new render surface. | 512 // The child layer's draw transform should refer to its new render surface. |
512 // The screen-space transform, however, should still refer to the root. | 513 // The screen-space transform, however, should still refer to the root. |
513 EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform, | 514 EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform, |
514 child->draw_transform()); | 515 child->DrawTransform()); |
515 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, | 516 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, |
516 child->screen_space_transform()); | 517 child->screen_space_transform()); |
517 | 518 |
518 // Because the grand_child is the only drawable content, the child's render | 519 // Because the grand_child is the only drawable content, the child's render |
519 // surface will tighten its bounds to the grand_child. The scale at which the | 520 // surface will tighten its bounds to the grand_child. The scale at which the |
520 // surface's subtree is drawn must be removed from the composite transform. | 521 // surface's subtree is drawn must be removed from the composite transform. |
521 EXPECT_TRANSFORMATION_MATRIX_EQ( | 522 EXPECT_TRANSFORMATION_MATRIX_EQ( |
522 surface_sublayer_composite_transform, | 523 surface_sublayer_composite_transform, |
523 child->render_target()->render_surface()->draw_transform()); | 524 child->render_target()->render_surface()->draw_transform()); |
524 | 525 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
563 expected_grand_child_screen_space_transform.Rotate(45.0); | 564 expected_grand_child_screen_space_transform.Rotate(45.0); |
564 expected_grand_child_screen_space_transform.Translate(2.0, 2.0); | 565 expected_grand_child_screen_space_transform.Translate(2.0, 2.0); |
565 | 566 |
566 // First compute draw properties with separate surfaces enabled. | 567 // First compute draw properties with separate surfaces enabled. |
567 ExecuteCalculateDrawProperties(root); | 568 ExecuteCalculateDrawProperties(root); |
568 | 569 |
569 // The grand child's draw transform should be its offset wrt the child. | 570 // The grand child's draw transform should be its offset wrt the child. |
570 gfx::Transform expected_grand_child_draw_transform; | 571 gfx::Transform expected_grand_child_draw_transform; |
571 expected_grand_child_draw_transform.Translate(2.0, 2.0); | 572 expected_grand_child_draw_transform.Translate(2.0, 2.0); |
572 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform, | 573 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform, |
573 grand_child->draw_transform()); | 574 grand_child->DrawTransform()); |
574 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, | 575 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, |
575 grand_child->screen_space_transform()); | 576 grand_child->screen_space_transform()); |
576 | 577 |
577 ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root); | 578 ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root); |
578 | 579 |
579 // With separate surfaces disabled, the grand child's draw transform should be | 580 // With separate surfaces disabled, the grand child's draw transform should be |
580 // the same as its screen space transform. | 581 // the same as its screen space transform. |
581 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, | 582 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, |
582 grand_child->draw_transform()); | 583 grand_child->DrawTransform()); |
583 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, | 584 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, |
584 grand_child->screen_space_transform()); | 585 grand_child->screen_space_transform()); |
585 } | 586 } |
586 | 587 |
587 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) { | 588 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) { |
588 LayerImpl* root = root_layer(); | 589 LayerImpl* root = root_layer(); |
589 LayerImpl* parent = AddChildToRoot<LayerImpl>(); | 590 LayerImpl* parent = AddChildToRoot<LayerImpl>(); |
590 LayerImpl* child = AddChild<LayerImpl>(parent); | 591 LayerImpl* child = AddChild<LayerImpl>(parent); |
591 LayerImpl* grand_child = AddChild<LayerImpl>(child); | 592 LayerImpl* grand_child = AddChild<LayerImpl>(child); |
592 grand_child->SetDrawsContent(true); | 593 grand_child->SetDrawsContent(true); |
(...skipping 210 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
803 EXPECT_EQ(render_surface1, child_of_rs1->render_target()); | 804 EXPECT_EQ(render_surface1, child_of_rs1->render_target()); |
804 EXPECT_EQ(render_surface1, grand_child_of_rs1->render_target()); | 805 EXPECT_EQ(render_surface1, grand_child_of_rs1->render_target()); |
805 | 806 |
806 EXPECT_EQ(render_surface2, render_surface2->render_target()); | 807 EXPECT_EQ(render_surface2, render_surface2->render_target()); |
807 EXPECT_EQ(render_surface2, child_of_rs2->render_target()); | 808 EXPECT_EQ(render_surface2, child_of_rs2->render_target()); |
808 EXPECT_EQ(render_surface2, grand_child_of_rs2->render_target()); | 809 EXPECT_EQ(render_surface2, grand_child_of_rs2->render_target()); |
809 | 810 |
810 // Verify layer draw transforms note that draw transforms are described with | 811 // Verify layer draw transforms note that draw transforms are described with |
811 // respect to the nearest ancestor render surface but screen space transforms | 812 // respect to the nearest ancestor render surface but screen space transforms |
812 // are described with respect to the root. | 813 // are described with respect to the root. |
813 EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->draw_transform()); | 814 EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->DrawTransform()); |
814 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->draw_transform()); | 815 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->DrawTransform()); |
815 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A, | 816 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A, |
816 grand_child_of_root->draw_transform()); | 817 grand_child_of_root->DrawTransform()); |
817 | 818 |
818 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->draw_transform()); | 819 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->DrawTransform()); |
819 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A, child_of_rs1->draw_transform()); | 820 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A, child_of_rs1->DrawTransform()); |
820 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A * A, | 821 EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A * A, |
821 grand_child_of_rs1->draw_transform()); | 822 grand_child_of_rs1->DrawTransform()); |
822 | 823 |
823 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, render_surface2->draw_transform()); | 824 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, render_surface2->DrawTransform()); |
824 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A, child_of_rs2->draw_transform()); | 825 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A, child_of_rs2->DrawTransform()); |
825 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A * A, | 826 EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A * A, |
826 grand_child_of_rs2->draw_transform()); | 827 grand_child_of_rs2->DrawTransform()); |
827 | 828 |
828 // Verify layer screen-space transforms | 829 // Verify layer screen-space transforms |
829 // | 830 // |
830 EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screen_space_transform()); | 831 EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screen_space_transform()); |
831 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, | 832 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, |
832 child_of_root->screen_space_transform()); | 833 child_of_root->screen_space_transform()); |
833 EXPECT_TRANSFORMATION_MATRIX_EQ( | 834 EXPECT_TRANSFORMATION_MATRIX_EQ( |
834 A * A * A, grand_child_of_root->screen_space_transform()); | 835 A * A * A, grand_child_of_root->screen_space_transform()); |
835 | 836 |
836 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, | 837 EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
949 | 950 |
950 ExecuteCalculateDrawProperties(root); | 951 ExecuteCalculateDrawProperties(root); |
951 | 952 |
952 // The child's draw transform should have been taken by its surface. | 953 // The child's draw transform should have been taken by its surface. |
953 ASSERT_TRUE(child->render_surface()); | 954 ASSERT_TRUE(child->render_surface()); |
954 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform, | 955 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform, |
955 child->render_surface()->draw_transform()); | 956 child->render_surface()->draw_transform()); |
956 EXPECT_TRANSFORMATION_MATRIX_EQ( | 957 EXPECT_TRANSFORMATION_MATRIX_EQ( |
957 expected_child_screen_space_transform, | 958 expected_child_screen_space_transform, |
958 child->render_surface()->screen_space_transform()); | 959 child->render_surface()->screen_space_transform()); |
959 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); | 960 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform()); |
960 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform, | 961 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform, |
961 child->screen_space_transform()); | 962 child->screen_space_transform()); |
962 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform, | 963 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform, |
963 grand_child->draw_transform()); | 964 grand_child->DrawTransform()); |
964 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, | 965 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform, |
965 grand_child->screen_space_transform()); | 966 grand_child->screen_space_transform()); |
966 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform, | 967 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform, |
967 great_grand_child->draw_transform()); | 968 great_grand_child->DrawTransform()); |
968 EXPECT_TRANSFORMATION_MATRIX_EQ( | 969 EXPECT_TRANSFORMATION_MATRIX_EQ( |
969 expected_great_grand_child_screen_space_transform, | 970 expected_great_grand_child_screen_space_transform, |
970 great_grand_child->screen_space_transform()); | 971 great_grand_child->screen_space_transform()); |
971 } | 972 } |
972 | 973 |
973 TEST_F(LayerTreeHostCommonTest, LayerFullyContainedWithinClipInTargetSpace) { | 974 TEST_F(LayerTreeHostCommonTest, LayerFullyContainedWithinClipInTargetSpace) { |
974 scoped_refptr<Layer> root = Layer::Create(layer_settings()); | 975 scoped_refptr<Layer> root = Layer::Create(layer_settings()); |
975 scoped_refptr<Layer> child = Layer::Create(layer_settings()); | 976 scoped_refptr<Layer> child = Layer::Create(layer_settings()); |
976 scoped_refptr<LayerWithForcedDrawsContent> grand_child = | 977 scoped_refptr<LayerWithForcedDrawsContent> grand_child = |
977 make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings())); | 978 make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings())); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1034 SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(), | 1035 SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(), |
1035 gfx::PointF(), gfx::Size(10, 10), true, false, | 1036 gfx::PointF(), gfx::Size(10, 10), true, false, |
1036 false); | 1037 false); |
1037 | 1038 |
1038 ExecuteCalculateDrawProperties(root); | 1039 ExecuteCalculateDrawProperties(root); |
1039 | 1040 |
1040 ASSERT_TRUE(child->has_render_surface()); | 1041 ASSERT_TRUE(child->has_render_surface()); |
1041 // This is the real test, the rest are sanity checks. | 1042 // This is the real test, the rest are sanity checks. |
1042 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 1043 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
1043 child->render_surface()->draw_transform()); | 1044 child->render_surface()->draw_transform()); |
1044 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); | 1045 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform()); |
1045 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 1046 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
1046 grand_child->draw_transform()); | 1047 grand_child->DrawTransform()); |
1047 } | 1048 } |
1048 | 1049 |
1049 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) { | 1050 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) { |
1050 // Transformations applied at the root of the tree should be forwarded | 1051 // Transformations applied at the root of the tree should be forwarded |
1051 // to child layers instead of applied to the root RenderSurface. | 1052 // to child layers instead of applied to the root RenderSurface. |
1052 const gfx::Transform identity_matrix; | 1053 const gfx::Transform identity_matrix; |
1053 LayerImpl* root = root_layer(); | 1054 LayerImpl* root = root_layer(); |
1054 root->SetDrawsContent(true); | 1055 root->SetDrawsContent(true); |
1055 LayerImpl* child = AddChild<LayerImpl>(root); | 1056 LayerImpl* child = AddChild<LayerImpl>(root); |
1056 child->SetDrawsContent(true); | 1057 child->SetDrawsContent(true); |
1057 | 1058 |
1058 child->SetScrollClipLayer(root->id()); | 1059 child->SetScrollClipLayer(root->id()); |
1059 | 1060 |
1060 SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(), | 1061 SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(), |
1061 gfx::PointF(), gfx::Size(20, 20), true, false, | 1062 gfx::PointF(), gfx::Size(20, 20), true, false, |
1062 true); | 1063 true); |
1063 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), | 1064 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), |
1064 gfx::PointF(), gfx::Size(20, 20), true, false, | 1065 gfx::PointF(), gfx::Size(20, 20), true, false, |
1065 false); | 1066 false); |
1066 | 1067 |
1067 gfx::Transform translate; | 1068 gfx::Transform translate; |
1068 translate.Translate(50, 50); | 1069 translate.Translate(50, 50); |
1069 { | 1070 { |
1070 LayerImplList render_surface_layer_list_impl; | 1071 LayerImplList render_surface_layer_list_impl; |
| 1072 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1071 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1073 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1072 root, root->bounds(), translate, &render_surface_layer_list_impl); | 1074 root, root->bounds(), translate, &render_surface_layer_list_impl, |
| 1075 root->layer_tree_impl()->current_render_surface_list_id()); |
1073 inputs.property_trees->needs_rebuild = true; | 1076 inputs.property_trees->needs_rebuild = true; |
1074 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1077 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1075 EXPECT_EQ(translate, root->draw_properties().target_space_transform); | 1078 EXPECT_EQ(translate, root->draw_properties().target_space_transform); |
1076 EXPECT_EQ(translate, child->draw_properties().target_space_transform); | 1079 EXPECT_EQ(translate, child->draw_properties().target_space_transform); |
1077 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1080 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1078 } | 1081 } |
1079 | 1082 |
1080 gfx::Transform scale; | 1083 gfx::Transform scale; |
1081 scale.Scale(2, 2); | 1084 scale.Scale(2, 2); |
1082 { | 1085 { |
1083 LayerImplList render_surface_layer_list_impl; | 1086 LayerImplList render_surface_layer_list_impl; |
| 1087 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1084 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1088 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1085 root, root->bounds(), scale, &render_surface_layer_list_impl); | 1089 root, root->bounds(), scale, &render_surface_layer_list_impl, |
| 1090 root->layer_tree_impl()->current_render_surface_list_id()); |
1086 inputs.property_trees->needs_rebuild = true; | 1091 inputs.property_trees->needs_rebuild = true; |
1087 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1092 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1088 EXPECT_EQ(scale, root->draw_properties().target_space_transform); | 1093 EXPECT_EQ(scale, root->draw_properties().target_space_transform); |
1089 EXPECT_EQ(scale, child->draw_properties().target_space_transform); | 1094 EXPECT_EQ(scale, child->draw_properties().target_space_transform); |
1090 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1095 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1091 } | 1096 } |
1092 | 1097 |
1093 gfx::Transform rotate; | 1098 gfx::Transform rotate; |
1094 rotate.Rotate(2); | 1099 rotate.Rotate(2); |
1095 { | 1100 { |
1096 LayerImplList render_surface_layer_list_impl; | 1101 LayerImplList render_surface_layer_list_impl; |
| 1102 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1097 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1103 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1098 root, root->bounds(), rotate, &render_surface_layer_list_impl); | 1104 root, root->bounds(), rotate, &render_surface_layer_list_impl, |
| 1105 root->layer_tree_impl()->current_render_surface_list_id()); |
1099 inputs.property_trees->needs_rebuild = true; | 1106 inputs.property_trees->needs_rebuild = true; |
1100 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1107 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1101 EXPECT_EQ(rotate, root->draw_properties().target_space_transform); | 1108 EXPECT_EQ(rotate, root->draw_properties().target_space_transform); |
1102 EXPECT_EQ(rotate, child->draw_properties().target_space_transform); | 1109 EXPECT_EQ(rotate, child->draw_properties().target_space_transform); |
1103 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1110 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1104 } | 1111 } |
1105 | 1112 |
1106 gfx::Transform composite; | 1113 gfx::Transform composite; |
1107 composite.ConcatTransform(translate); | 1114 composite.ConcatTransform(translate); |
1108 composite.ConcatTransform(scale); | 1115 composite.ConcatTransform(scale); |
1109 composite.ConcatTransform(rotate); | 1116 composite.ConcatTransform(rotate); |
1110 { | 1117 { |
1111 LayerImplList render_surface_layer_list_impl; | 1118 LayerImplList render_surface_layer_list_impl; |
| 1119 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1112 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1120 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1113 root, root->bounds(), composite, &render_surface_layer_list_impl); | 1121 root, root->bounds(), composite, &render_surface_layer_list_impl, |
| 1122 root->layer_tree_impl()->current_render_surface_list_id()); |
1114 inputs.property_trees->needs_rebuild = true; | 1123 inputs.property_trees->needs_rebuild = true; |
1115 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1124 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1116 EXPECT_EQ(composite, root->draw_properties().target_space_transform); | 1125 EXPECT_EQ(composite, root->draw_properties().target_space_transform); |
1117 EXPECT_EQ(composite, child->draw_properties().target_space_transform); | 1126 EXPECT_EQ(composite, child->draw_properties().target_space_transform); |
1118 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1127 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1119 } | 1128 } |
1120 | 1129 |
1121 // Verify it composes correctly with device scale. | 1130 // Verify it composes correctly with device scale. |
1122 float device_scale_factor = 1.5f; | 1131 float device_scale_factor = 1.5f; |
1123 | 1132 |
1124 { | 1133 { |
1125 LayerImplList render_surface_layer_list_impl; | 1134 LayerImplList render_surface_layer_list_impl; |
| 1135 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1126 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1136 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1127 root, root->bounds(), translate, &render_surface_layer_list_impl); | 1137 root, root->bounds(), translate, &render_surface_layer_list_impl, |
| 1138 root->layer_tree_impl()->current_render_surface_list_id()); |
1128 inputs.device_scale_factor = device_scale_factor; | 1139 inputs.device_scale_factor = device_scale_factor; |
1129 inputs.property_trees->needs_rebuild = true; | 1140 inputs.property_trees->needs_rebuild = true; |
1130 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1141 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1131 gfx::Transform device_scaled_translate = translate; | 1142 gfx::Transform device_scaled_translate = translate; |
1132 device_scaled_translate.Scale(device_scale_factor, device_scale_factor); | 1143 device_scaled_translate.Scale(device_scale_factor, device_scale_factor); |
1133 EXPECT_EQ(device_scaled_translate, | 1144 EXPECT_EQ(device_scaled_translate, |
1134 root->draw_properties().target_space_transform); | 1145 root->draw_properties().target_space_transform); |
1135 EXPECT_EQ(device_scaled_translate, | 1146 EXPECT_EQ(device_scaled_translate, |
1136 child->draw_properties().target_space_transform); | 1147 child->draw_properties().target_space_transform); |
1137 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1148 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1138 } | 1149 } |
1139 | 1150 |
1140 // Verify it composes correctly with page scale. | 1151 // Verify it composes correctly with page scale. |
1141 float page_scale_factor = 2.f; | 1152 float page_scale_factor = 2.f; |
1142 | 1153 |
1143 { | 1154 { |
1144 LayerImplList render_surface_layer_list_impl; | 1155 LayerImplList render_surface_layer_list_impl; |
| 1156 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1145 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1157 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1146 root, root->bounds(), translate, &render_surface_layer_list_impl); | 1158 root, root->bounds(), translate, &render_surface_layer_list_impl, |
| 1159 root->layer_tree_impl()->current_render_surface_list_id()); |
1147 inputs.page_scale_factor = page_scale_factor; | 1160 inputs.page_scale_factor = page_scale_factor; |
1148 inputs.page_scale_layer = root; | 1161 inputs.page_scale_layer = root; |
1149 inputs.property_trees->needs_rebuild = true; | 1162 inputs.property_trees->needs_rebuild = true; |
1150 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1163 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1151 gfx::Transform page_scaled_translate = translate; | 1164 gfx::Transform page_scaled_translate = translate; |
1152 page_scaled_translate.Scale(page_scale_factor, page_scale_factor); | 1165 page_scaled_translate.Scale(page_scale_factor, page_scale_factor); |
1153 EXPECT_EQ(page_scaled_translate, | 1166 EXPECT_EQ(page_scaled_translate, |
1154 root->draw_properties().target_space_transform); | 1167 root->draw_properties().target_space_transform); |
1155 EXPECT_EQ(page_scaled_translate, | 1168 EXPECT_EQ(page_scaled_translate, |
1156 child->draw_properties().target_space_transform); | 1169 child->draw_properties().target_space_transform); |
1157 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1170 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1158 } | 1171 } |
1159 | 1172 |
1160 // Verify that it composes correctly with transforms directly on root layer. | 1173 // Verify that it composes correctly with transforms directly on root layer. |
1161 root->SetTransform(composite); | 1174 root->SetTransform(composite); |
1162 | 1175 |
1163 { | 1176 { |
1164 LayerImplList render_surface_layer_list_impl; | 1177 LayerImplList render_surface_layer_list_impl; |
| 1178 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1165 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1179 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1166 root, root->bounds(), composite, &render_surface_layer_list_impl); | 1180 root, root->bounds(), composite, &render_surface_layer_list_impl, |
| 1181 root->layer_tree_impl()->current_render_surface_list_id()); |
1167 inputs.property_trees->needs_rebuild = true; | 1182 inputs.property_trees->needs_rebuild = true; |
1168 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1183 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1169 gfx::Transform compositeSquared = composite; | 1184 gfx::Transform compositeSquared = composite; |
1170 compositeSquared.ConcatTransform(composite); | 1185 compositeSquared.ConcatTransform(composite); |
1171 EXPECT_TRANSFORMATION_MATRIX_EQ( | 1186 EXPECT_TRANSFORMATION_MATRIX_EQ( |
1172 compositeSquared, root->draw_properties().target_space_transform); | 1187 compositeSquared, root->draw_properties().target_space_transform); |
1173 EXPECT_TRANSFORMATION_MATRIX_EQ( | 1188 EXPECT_TRANSFORMATION_MATRIX_EQ( |
1174 compositeSquared, child->draw_properties().target_space_transform); | 1189 compositeSquared, child->draw_properties().target_space_transform); |
1175 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); | 1190 EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform()); |
1176 } | 1191 } |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1215 const gfx::Transform identity_matrix; | 1230 const gfx::Transform identity_matrix; |
1216 SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(), | 1231 SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(), |
1217 gfx::PointF(), gfx::Size(10, 10), true, false, | 1232 gfx::PointF(), gfx::Size(10, 10), true, false, |
1218 true); | 1233 true); |
1219 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), | 1234 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), |
1220 gfx::PointF(), gfx::Size(10, 10), true, false, | 1235 gfx::PointF(), gfx::Size(10, 10), true, false, |
1221 false); | 1236 false); |
1222 render_surface1->SetOpacity(0.f); | 1237 render_surface1->SetOpacity(0.f); |
1223 | 1238 |
1224 LayerImplList render_surface_layer_list; | 1239 LayerImplList render_surface_layer_list; |
| 1240 parent->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1225 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1241 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1226 parent, parent->bounds(), &render_surface_layer_list); | 1242 parent, parent->bounds(), &render_surface_layer_list, |
| 1243 parent->layer_tree_impl()->current_render_surface_list_id()); |
1227 inputs.can_adjust_raster_scales = true; | 1244 inputs.can_adjust_raster_scales = true; |
1228 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1245 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1229 | 1246 |
1230 // Since the layer is transparent, render_surface1->render_surface() should | 1247 // Since the layer is transparent, render_surface1->render_surface() should |
1231 // not have gotten added anywhere. Also, the drawable content rect should not | 1248 // not have gotten added anywhere. Also, the drawable content rect should not |
1232 // have been extended by the children. | 1249 // have been extended by the children. |
1233 ASSERT_TRUE(parent->render_surface()); | 1250 ASSERT_TRUE(parent->render_surface()); |
1234 EXPECT_EQ(0U, parent->render_surface()->layer_list().size()); | 1251 EXPECT_EQ(0U, parent->render_surface()->layer_list().size()); |
1235 EXPECT_EQ(1U, render_surface_layer_list.size()); | 1252 EXPECT_EQ(1U, render_surface_layer_list.size()); |
1236 EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id()); | 1253 EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id()); |
(...skipping 16 matching lines...) Expand all Loading... |
1253 true); | 1270 true); |
1254 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), | 1271 SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(), |
1255 gfx::PointF(), gfx::Size(10, 10), true, false, | 1272 gfx::PointF(), gfx::Size(10, 10), true, false, |
1256 false); | 1273 false); |
1257 render_surface1->SetOpacity(0.f); | 1274 render_surface1->SetOpacity(0.f); |
1258 FilterOperations filters; | 1275 FilterOperations filters; |
1259 filters.Append(FilterOperation::CreateBlurFilter(1.5f)); | 1276 filters.Append(FilterOperation::CreateBlurFilter(1.5f)); |
1260 render_surface1->SetBackgroundFilters(filters); | 1277 render_surface1->SetBackgroundFilters(filters); |
1261 | 1278 |
1262 LayerImplList render_surface_layer_list; | 1279 LayerImplList render_surface_layer_list; |
| 1280 parent->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
1263 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 1281 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
1264 parent, parent->bounds(), &render_surface_layer_list); | 1282 parent, parent->bounds(), &render_surface_layer_list, |
| 1283 parent->layer_tree_impl()->current_render_surface_list_id()); |
1265 inputs.can_adjust_raster_scales = true; | 1284 inputs.can_adjust_raster_scales = true; |
1266 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 1285 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
1267 | 1286 |
1268 // The layer is fully transparent, but has a background filter, so it | 1287 // The layer is fully transparent, but has a background filter, so it |
1269 // shouldn't be skipped. | 1288 // shouldn't be skipped. |
1270 ASSERT_TRUE(parent->render_surface()); | 1289 ASSERT_TRUE(parent->render_surface()); |
1271 EXPECT_EQ(1U, parent->render_surface()->layer_list().size()); | 1290 EXPECT_EQ(1U, parent->render_surface()->layer_list().size()); |
1272 EXPECT_EQ(2U, render_surface_layer_list.size()); | 1291 EXPECT_EQ(2U, render_surface_layer_list.size()); |
1273 EXPECT_EQ(gfx::RectF(0, 0, 10, 10), | 1292 EXPECT_EQ(gfx::RectF(0, 0, 10, 10), |
1274 parent->render_surface()->DrawableContentRect()); | 1293 parent->render_surface()->DrawableContentRect()); |
(...skipping 208 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1483 | 1502 |
1484 gfx::Transform flattened_rotation_about_y = rotation_about_y_axis; | 1503 gfx::Transform flattened_rotation_about_y = rotation_about_y_axis; |
1485 flattened_rotation_about_y.FlattenTo2d(); | 1504 flattened_rotation_about_y.FlattenTo2d(); |
1486 | 1505 |
1487 ExecuteCalculateDrawProperties(root); | 1506 ExecuteCalculateDrawProperties(root); |
1488 | 1507 |
1489 EXPECT_TRUE(parent->render_surface()); | 1508 EXPECT_TRUE(parent->render_surface()); |
1490 EXPECT_FALSE(child->render_surface()); | 1509 EXPECT_FALSE(child->render_surface()); |
1491 EXPECT_FALSE(grand_child->render_surface()); | 1510 EXPECT_FALSE(grand_child->render_surface()); |
1492 | 1511 |
1493 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); | 1512 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform()); |
1494 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 1513 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
1495 grand_child->draw_transform()); | 1514 grand_child->DrawTransform()); |
1496 | 1515 |
1497 // The screen-space transform inherited by |child| and |grand_child| should | 1516 // The screen-space transform inherited by |child| and |grand_child| should |
1498 // have been flattened at their render target. In particular, the fact that | 1517 // have been flattened at their render target. In particular, the fact that |
1499 // |grand_child| happens to preserve 3d shouldn't affect this flattening. | 1518 // |grand_child| happens to preserve 3d shouldn't affect this flattening. |
1500 EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y, | 1519 EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y, |
1501 child->screen_space_transform()); | 1520 child->screen_space_transform()); |
1502 EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y, | 1521 EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y, |
1503 grand_child->screen_space_transform()); | 1522 grand_child->screen_space_transform()); |
1504 } | 1523 } |
1505 | 1524 |
(...skipping 692 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2198 gfx::Transform expected_leaf_draw_transform_with_surfaces; | 2217 gfx::Transform expected_leaf_draw_transform_with_surfaces; |
2199 expected_leaf_draw_transform_with_surfaces.Translate(16.0, 16.0); | 2218 expected_leaf_draw_transform_with_surfaces.Translate(16.0, 16.0); |
2200 | 2219 |
2201 gfx::Transform expected_leaf_draw_transform_without_surfaces; | 2220 gfx::Transform expected_leaf_draw_transform_without_surfaces; |
2202 expected_leaf_draw_transform_without_surfaces.Translate(30.0, 30.0); | 2221 expected_leaf_draw_transform_without_surfaces.Translate(30.0, 30.0); |
2203 | 2222 |
2204 ExecuteCalculateDrawProperties(root); | 2223 ExecuteCalculateDrawProperties(root); |
2205 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect()); | 2224 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect()); |
2206 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect()); | 2225 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect()); |
2207 EXPECT_EQ(expected_leaf_draw_transform_with_surfaces, | 2226 EXPECT_EQ(expected_leaf_draw_transform_with_surfaces, |
2208 leaf_node->draw_transform()); | 2227 leaf_node->DrawTransform()); |
2209 | 2228 |
2210 ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root); | 2229 ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root); |
2211 EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node->clip_rect()); | 2230 EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node->clip_rect()); |
2212 EXPECT_EQ(gfx::Rect(30, 30, 372, 372), leaf_node->drawable_content_rect()); | 2231 EXPECT_EQ(gfx::Rect(30, 30, 372, 372), leaf_node->drawable_content_rect()); |
2213 EXPECT_EQ(expected_leaf_draw_transform_without_surfaces, | 2232 EXPECT_EQ(expected_leaf_draw_transform_without_surfaces, |
2214 leaf_node->draw_transform()); | 2233 leaf_node->DrawTransform()); |
2215 | 2234 |
2216 ExecuteCalculateDrawProperties(root); | 2235 ExecuteCalculateDrawProperties(root); |
2217 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect()); | 2236 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect()); |
2218 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect()); | 2237 EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect()); |
2219 EXPECT_EQ(expected_leaf_draw_transform_with_surfaces, | 2238 EXPECT_EQ(expected_leaf_draw_transform_with_surfaces, |
2220 leaf_node->draw_transform()); | 2239 leaf_node->DrawTransform()); |
2221 } | 2240 } |
2222 | 2241 |
2223 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) { | 2242 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) { |
2224 LayerImpl* parent = root_layer(); | 2243 LayerImpl* parent = root_layer(); |
2225 LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>(); | 2244 LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>(); |
2226 LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1); | 2245 LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1); |
2227 LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1); | 2246 LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1); |
2228 LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1); | 2247 LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1); |
2229 LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2); | 2248 LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2); |
2230 LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2); | 2249 LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2); |
(...skipping 885 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3116 gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true, | 3135 gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true, |
3117 false, false); | 3136 false, false); |
3118 SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(), | 3137 SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(), |
3119 gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true, | 3138 gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true, |
3120 false, false); | 3139 false, false); |
3121 SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(), | 3140 SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(), |
3122 gfx::PointF(125.f, 125.f), gfx::Size(50, 50), | 3141 gfx::PointF(125.f, 125.f), gfx::Size(50, 50), |
3123 true, false, false); | 3142 true, false, false); |
3124 | 3143 |
3125 LayerImplList render_surface_layer_list_impl; | 3144 LayerImplList render_surface_layer_list_impl; |
| 3145 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
3126 // Now set the root render surface an empty clip. | 3146 // Now set the root render surface an empty clip. |
3127 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 3147 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
3128 root, gfx::Size(), &render_surface_layer_list_impl); | 3148 root, gfx::Size(), &render_surface_layer_list_impl, |
| 3149 root->layer_tree_impl()->current_render_surface_list_id()); |
3129 | 3150 |
3130 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 3151 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
3131 ASSERT_TRUE(root->render_surface()); | 3152 ASSERT_TRUE(root->render_surface()); |
3132 EXPECT_FALSE(root->is_clipped()); | 3153 EXPECT_FALSE(root->is_clipped()); |
3133 | 3154 |
3134 gfx::Rect empty; | 3155 gfx::Rect empty; |
3135 EXPECT_EQ(empty, root->render_surface()->clip_rect()); | 3156 EXPECT_EQ(empty, root->render_surface()->clip_rect()); |
3136 EXPECT_TRUE(root->render_surface()->is_clipped()); | 3157 EXPECT_TRUE(root->render_surface()->is_clipped()); |
3137 | 3158 |
3138 // Visible content rect calculation will check if the target surface is | 3159 // Visible content rect calculation will check if the target surface is |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3220 gfx::PointF(10.f, 10.f), gfx::Size(100, 100), | 3241 gfx::PointF(10.f, 10.f), gfx::Size(100, 100), |
3221 false, true, false); | 3242 false, true, false); |
3222 SetLayerPropertiesForTesting(grand_child, rotation, gfx::Point3F(), | 3243 SetLayerPropertiesForTesting(grand_child, rotation, gfx::Point3F(), |
3223 gfx::PointF(), gfx::Size(100, 100), false, true, | 3244 gfx::PointF(), gfx::Size(100, 100), false, true, |
3224 false); | 3245 false); |
3225 | 3246 |
3226 ExecuteCalculateDrawProperties(root); | 3247 ExecuteCalculateDrawProperties(root); |
3227 | 3248 |
3228 // Though all layers have invertible transforms, matrix multiplication using | 3249 // Though all layers have invertible transforms, matrix multiplication using |
3229 // floating-point math makes the draw transform uninvertible. | 3250 // floating-point math makes the draw transform uninvertible. |
3230 EXPECT_FALSE(grand_child->draw_transform().IsInvertible()); | 3251 EXPECT_FALSE(grand_child->DrawTransform().IsInvertible()); |
3231 | 3252 |
3232 // CalcDrawProps only skips a subtree when a layer's own transform is | 3253 // CalcDrawProps only skips a subtree when a layer's own transform is |
3233 // uninvertible, not when its draw transform is invertible, since CDP makes | 3254 // uninvertible, not when its draw transform is invertible, since CDP makes |
3234 // skipping decisions before computing a layer's draw transform. Property | 3255 // skipping decisions before computing a layer's draw transform. Property |
3235 // trees make skipping decisions after computing draw transforms, so could be | 3256 // trees make skipping decisions after computing draw transforms, so could be |
3236 // made to skip layers with an uninvertible draw transform (once CDP is | 3257 // made to skip layers with an uninvertible draw transform (once CDP is |
3237 // deleted). | 3258 // deleted). |
3238 EXPECT_EQ(gfx::Rect(grand_child->bounds()), | 3259 EXPECT_EQ(gfx::Rect(grand_child->bounds()), |
3239 grand_child->visible_layer_rect()); | 3260 grand_child->visible_layer_rect()); |
3240 } | 3261 } |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3288 host_impl.InitializeRenderer(output_surface.get()); | 3309 host_impl.InitializeRenderer(output_surface.get()); |
3289 host_impl.active_tree()->BuildPropertyTreesForTesting(); | 3310 host_impl.active_tree()->BuildPropertyTreesForTesting(); |
3290 bool update_lcd_text = false; | 3311 bool update_lcd_text = false; |
3291 host_impl.active_tree()->UpdateDrawProperties(update_lcd_text); | 3312 host_impl.active_tree()->UpdateDrawProperties(update_lcd_text); |
3292 | 3313 |
3293 LayerImpl* grand_child_ptr = | 3314 LayerImpl* grand_child_ptr = |
3294 host_impl.active_tree()->root_layer()->children()[0]->children()[0].get(); | 3315 host_impl.active_tree()->root_layer()->children()[0]->children()[0].get(); |
3295 | 3316 |
3296 // Though all layers have invertible transforms, matrix multiplication using | 3317 // Though all layers have invertible transforms, matrix multiplication using |
3297 // floating-point math makes the draw transform uninvertible. | 3318 // floating-point math makes the draw transform uninvertible. |
3298 EXPECT_FALSE(grand_child_ptr->draw_transform().IsInvertible()); | 3319 EXPECT_FALSE(grand_child_ptr->DrawTransform().IsInvertible()); |
3299 | 3320 |
3300 // Since |grand_child| has an uninvertible draw transform, it is treated as | 3321 // Since |grand_child| has an uninvertible draw transform, it is treated as |
3301 // unoccluded (even though |occluding_child| comes later in draw order, and | 3322 // unoccluded (even though |occluding_child| comes later in draw order, and |
3302 // hence potentially occludes it). | 3323 // hence potentially occludes it). |
3303 gfx::Rect layer_bounds = gfx::Rect(grand_child_ptr->bounds()); | 3324 gfx::Rect layer_bounds = gfx::Rect(grand_child_ptr->bounds()); |
3304 EXPECT_EQ( | 3325 EXPECT_EQ( |
3305 layer_bounds, | 3326 layer_bounds, |
3306 grand_child_ptr->draw_properties() | 3327 grand_child_ptr->draw_properties() |
3307 .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds)); | 3328 .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds)); |
3308 } | 3329 } |
(...skipping 1159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4468 EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child2); | 4489 EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child2); |
4469 | 4490 |
4470 EXPECT_EQ(1u, render_surface_layer_list_impl()->size()); | 4491 EXPECT_EQ(1u, render_surface_layer_list_impl()->size()); |
4471 | 4492 |
4472 // Verify parent transforms | 4493 // Verify parent transforms |
4473 gfx::Transform expected_parent_transform; | 4494 gfx::Transform expected_parent_transform; |
4474 expected_parent_transform.Scale(device_scale_factor, device_scale_factor); | 4495 expected_parent_transform.Scale(device_scale_factor, device_scale_factor); |
4475 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, | 4496 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, |
4476 parent->screen_space_transform()); | 4497 parent->screen_space_transform()); |
4477 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, | 4498 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, |
4478 parent->draw_transform()); | 4499 parent->DrawTransform()); |
4479 | 4500 |
4480 // Verify results of transformed parent rects | 4501 // Verify results of transformed parent rects |
4481 gfx::RectF parent_bounds(gfx::SizeF(parent->bounds())); | 4502 gfx::RectF parent_bounds(gfx::SizeF(parent->bounds())); |
4482 | 4503 |
4483 gfx::RectF parent_draw_rect = | 4504 gfx::RectF parent_draw_rect = |
4484 MathUtil::MapClippedRect(parent->draw_transform(), parent_bounds); | 4505 MathUtil::MapClippedRect(parent->DrawTransform(), parent_bounds); |
4485 gfx::RectF parent_screen_space_rect = | 4506 gfx::RectF parent_screen_space_rect = |
4486 MathUtil::MapClippedRect(parent->screen_space_transform(), parent_bounds); | 4507 MathUtil::MapClippedRect(parent->screen_space_transform(), parent_bounds); |
4487 | 4508 |
4488 gfx::RectF expected_parent_draw_rect(gfx::SizeF(parent->bounds())); | 4509 gfx::RectF expected_parent_draw_rect(gfx::SizeF(parent->bounds())); |
4489 expected_parent_draw_rect.Scale(device_scale_factor); | 4510 expected_parent_draw_rect.Scale(device_scale_factor); |
4490 EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect); | 4511 EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect); |
4491 EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect); | 4512 EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect); |
4492 | 4513 |
4493 // Verify child and child2 transforms. They should match. | 4514 // Verify child and child2 transforms. They should match. |
4494 gfx::Transform expected_child_transform; | 4515 gfx::Transform expected_child_transform; |
4495 expected_child_transform.Scale(device_scale_factor, device_scale_factor); | 4516 expected_child_transform.Scale(device_scale_factor, device_scale_factor); |
4496 expected_child_transform.Translate(child->position().x(), | 4517 expected_child_transform.Translate(child->position().x(), |
4497 child->position().y()); | 4518 child->position().y()); |
4498 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, | 4519 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, |
4499 child->draw_transform()); | 4520 child->DrawTransform()); |
4500 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, | 4521 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, |
4501 child->screen_space_transform()); | 4522 child->screen_space_transform()); |
4502 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, | 4523 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, |
4503 child2->draw_transform()); | 4524 child2->DrawTransform()); |
4504 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, | 4525 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform, |
4505 child2->screen_space_transform()); | 4526 child2->screen_space_transform()); |
4506 | 4527 |
4507 // Verify results of transformed child and child2 rects. They should | 4528 // Verify results of transformed child and child2 rects. They should |
4508 // match. | 4529 // match. |
4509 gfx::RectF child_bounds(gfx::SizeF(child->bounds())); | 4530 gfx::RectF child_bounds(gfx::SizeF(child->bounds())); |
4510 | 4531 |
4511 gfx::RectF child_draw_rect = | 4532 gfx::RectF child_draw_rect = |
4512 MathUtil::MapClippedRect(child->draw_transform(), child_bounds); | 4533 MathUtil::MapClippedRect(child->DrawTransform(), child_bounds); |
4513 gfx::RectF child_screen_space_rect = | 4534 gfx::RectF child_screen_space_rect = |
4514 MathUtil::MapClippedRect(child->screen_space_transform(), child_bounds); | 4535 MathUtil::MapClippedRect(child->screen_space_transform(), child_bounds); |
4515 | 4536 |
4516 gfx::RectF child2_draw_rect = | 4537 gfx::RectF child2_draw_rect = |
4517 MathUtil::MapClippedRect(child2->draw_transform(), child_bounds); | 4538 MathUtil::MapClippedRect(child2->DrawTransform(), child_bounds); |
4518 gfx::RectF child2_screen_space_rect = | 4539 gfx::RectF child2_screen_space_rect = |
4519 MathUtil::MapClippedRect(child2->screen_space_transform(), child_bounds); | 4540 MathUtil::MapClippedRect(child2->screen_space_transform(), child_bounds); |
4520 | 4541 |
4521 gfx::RectF expected_child_draw_rect(child->position(), | 4542 gfx::RectF expected_child_draw_rect(child->position(), |
4522 gfx::SizeF(child->bounds())); | 4543 gfx::SizeF(child->bounds())); |
4523 expected_child_draw_rect.Scale(device_scale_factor); | 4544 expected_child_draw_rect.Scale(device_scale_factor); |
4524 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect); | 4545 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect); |
4525 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect); | 4546 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect); |
4526 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_draw_rect); | 4547 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_draw_rect); |
4527 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_screen_space_rect); | 4548 EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_screen_space_rect); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4586 EXPECT_FLOAT_EQ(max_2d_scale, | 4607 EXPECT_FLOAT_EQ(max_2d_scale, |
4587 std::max(target_space_transform_scales.x(), | 4608 std::max(target_space_transform_scales.x(), |
4588 target_space_transform_scales.y())); | 4609 target_space_transform_scales.y())); |
4589 | 4610 |
4590 EXPECT_EQ(3u, render_surface_layer_list_impl()->size()); | 4611 EXPECT_EQ(3u, render_surface_layer_list_impl()->size()); |
4591 | 4612 |
4592 gfx::Transform expected_parent_draw_transform; | 4613 gfx::Transform expected_parent_draw_transform; |
4593 expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor, | 4614 expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor, |
4594 device_scale_factor * page_scale_factor); | 4615 device_scale_factor * page_scale_factor); |
4595 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform, | 4616 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform, |
4596 parent->draw_transform()); | 4617 parent->DrawTransform()); |
4597 | 4618 |
4598 // The scale for the perspective surface is not known, so it is rendered 1:1 | 4619 // The scale for the perspective surface is not known, so it is rendered 1:1 |
4599 // with the screen, and then scaled during drawing. | 4620 // with the screen, and then scaled during drawing. |
4600 gfx::Transform expected_perspective_surface_draw_transform; | 4621 gfx::Transform expected_perspective_surface_draw_transform; |
4601 expected_perspective_surface_draw_transform.Translate( | 4622 expected_perspective_surface_draw_transform.Translate( |
4602 device_scale_factor * page_scale_factor * | 4623 device_scale_factor * page_scale_factor * |
4603 perspective_surface->position().x(), | 4624 perspective_surface->position().x(), |
4604 device_scale_factor * page_scale_factor * | 4625 device_scale_factor * page_scale_factor * |
4605 perspective_surface->position().y()); | 4626 perspective_surface->position().y()); |
4606 expected_perspective_surface_draw_transform.PreconcatTransform( | 4627 expected_perspective_surface_draw_transform.PreconcatTransform( |
4607 perspective_matrix); | 4628 perspective_matrix); |
4608 expected_perspective_surface_draw_transform.PreconcatTransform( | 4629 expected_perspective_surface_draw_transform.PreconcatTransform( |
4609 scale_small_matrix); | 4630 scale_small_matrix); |
4610 gfx::Transform expected_perspective_surface_layer_draw_transform; | 4631 gfx::Transform expected_perspective_surface_layer_draw_transform; |
4611 expected_perspective_surface_layer_draw_transform.Scale( | 4632 expected_perspective_surface_layer_draw_transform.Scale( |
4612 device_scale_factor * page_scale_factor, | 4633 device_scale_factor * page_scale_factor, |
4613 device_scale_factor * page_scale_factor); | 4634 device_scale_factor * page_scale_factor); |
4614 EXPECT_TRANSFORMATION_MATRIX_EQ( | 4635 EXPECT_TRANSFORMATION_MATRIX_EQ( |
4615 expected_perspective_surface_draw_transform, | 4636 expected_perspective_surface_draw_transform, |
4616 perspective_surface->render_surface()->draw_transform()); | 4637 perspective_surface->render_surface()->draw_transform()); |
4617 EXPECT_TRANSFORMATION_MATRIX_EQ( | 4638 EXPECT_TRANSFORMATION_MATRIX_EQ( |
4618 expected_perspective_surface_layer_draw_transform, | 4639 expected_perspective_surface_layer_draw_transform, |
4619 perspective_surface->draw_transform()); | 4640 perspective_surface->DrawTransform()); |
4620 } | 4641 } |
4621 | 4642 |
4622 TEST_F(LayerTreeHostCommonScalingTest, SmallIdealScale) { | 4643 TEST_F(LayerTreeHostCommonScalingTest, SmallIdealScale) { |
4623 gfx::Transform parent_scale_matrix; | 4644 gfx::Transform parent_scale_matrix; |
4624 SkMScalar initial_parent_scale = 1.75; | 4645 SkMScalar initial_parent_scale = 1.75; |
4625 parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale); | 4646 parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale); |
4626 | 4647 |
4627 gfx::Transform child_scale_matrix; | 4648 gfx::Transform child_scale_matrix; |
4628 SkMScalar initial_child_scale = 0.25; | 4649 SkMScalar initial_child_scale = 0.25; |
4629 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4650 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4736 | 4757 |
4737 // We should have two render surfaces. The root's render surface and child's | 4758 // We should have two render surfaces. The root's render surface and child's |
4738 // render surface (it needs one because it has a replica layer). | 4759 // render surface (it needs one because it has a replica layer). |
4739 EXPECT_EQ(2u, render_surface_layer_list_impl()->size()); | 4760 EXPECT_EQ(2u, render_surface_layer_list_impl()->size()); |
4740 | 4761 |
4741 gfx::Transform expected_parent_transform; | 4762 gfx::Transform expected_parent_transform; |
4742 expected_parent_transform.Scale(device_scale_factor, device_scale_factor); | 4763 expected_parent_transform.Scale(device_scale_factor, device_scale_factor); |
4743 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, | 4764 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, |
4744 parent->screen_space_transform()); | 4765 parent->screen_space_transform()); |
4745 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, | 4766 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform, |
4746 parent->draw_transform()); | 4767 parent->DrawTransform()); |
4747 | 4768 |
4748 gfx::Transform expected_draw_transform; | 4769 gfx::Transform expected_draw_transform; |
4749 expected_draw_transform.Scale(device_scale_factor, device_scale_factor); | 4770 expected_draw_transform.Scale(device_scale_factor, device_scale_factor); |
4750 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_draw_transform, | 4771 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_draw_transform, |
4751 child->draw_transform()); | 4772 child->DrawTransform()); |
4752 | 4773 |
4753 gfx::Transform expected_screen_space_transform; | 4774 gfx::Transform expected_screen_space_transform; |
4754 expected_screen_space_transform.Scale(device_scale_factor, | 4775 expected_screen_space_transform.Scale(device_scale_factor, |
4755 device_scale_factor); | 4776 device_scale_factor); |
4756 expected_screen_space_transform.Translate(child->position().x(), | 4777 expected_screen_space_transform.Translate(child->position().x(), |
4757 child->position().y()); | 4778 child->position().y()); |
4758 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform, | 4779 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform, |
4759 child->screen_space_transform()); | 4780 child->screen_space_transform()); |
4760 | 4781 |
4761 gfx::Transform expected_duplicate_child_draw_transform = | 4782 gfx::Transform expected_duplicate_child_draw_transform = |
4762 child->draw_transform(); | 4783 child->DrawTransform(); |
4763 EXPECT_TRANSFORMATION_MATRIX_EQ(child->draw_transform(), | 4784 EXPECT_TRANSFORMATION_MATRIX_EQ(child->DrawTransform(), |
4764 duplicate_child_non_owner->draw_transform()); | 4785 duplicate_child_non_owner->DrawTransform()); |
4765 EXPECT_TRANSFORMATION_MATRIX_EQ( | 4786 EXPECT_TRANSFORMATION_MATRIX_EQ( |
4766 child->screen_space_transform(), | 4787 child->screen_space_transform(), |
4767 duplicate_child_non_owner->screen_space_transform()); | 4788 duplicate_child_non_owner->screen_space_transform()); |
4768 EXPECT_EQ(child->drawable_content_rect(), | 4789 EXPECT_EQ(child->drawable_content_rect(), |
4769 duplicate_child_non_owner->drawable_content_rect()); | 4790 duplicate_child_non_owner->drawable_content_rect()); |
4770 EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds()); | 4791 EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds()); |
4771 | 4792 |
4772 gfx::Transform expected_render_surface_draw_transform; | 4793 gfx::Transform expected_render_surface_draw_transform; |
4773 expected_render_surface_draw_transform.Translate( | 4794 expected_render_surface_draw_transform.Translate( |
4774 device_scale_factor * child->position().x(), | 4795 device_scale_factor * child->position().x(), |
(...skipping 182 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4957 child->SetOpacity(0.0f); | 4978 child->SetOpacity(0.0f); |
4958 | 4979 |
4959 // Add opacity animation. | 4980 // Add opacity animation. |
4960 AddOpacityTransitionToController( | 4981 AddOpacityTransitionToController( |
4961 child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false); | 4982 child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false); |
4962 | 4983 |
4963 root->AddChild(std::move(child)); | 4984 root->AddChild(std::move(child)); |
4964 root->SetHasRenderSurface(true); | 4985 root->SetHasRenderSurface(true); |
4965 | 4986 |
4966 LayerImplList render_surface_layer_list; | 4987 LayerImplList render_surface_layer_list; |
| 4988 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
4967 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 4989 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
4968 root.get(), root->bounds(), &render_surface_layer_list); | 4990 root.get(), root->bounds(), &render_surface_layer_list, |
| 4991 root->layer_tree_impl()->current_render_surface_list_id()); |
4969 inputs.can_adjust_raster_scales = true; | 4992 inputs.can_adjust_raster_scales = true; |
4970 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 4993 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
4971 | 4994 |
4972 // We should have one render surface and two layers. The child | 4995 // We should have one render surface and two layers. The child |
4973 // layer should be included even though it is transparent. | 4996 // layer should be included even though it is transparent. |
4974 ASSERT_EQ(1u, render_surface_layer_list.size()); | 4997 ASSERT_EQ(1u, render_surface_layer_list.size()); |
4975 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); | 4998 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); |
4976 } | 4999 } |
4977 | 5000 |
4978 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>; | 5001 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>; |
(...skipping 249 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5228 gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), | 5251 gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), |
5229 true, false, false); | 5252 true, false, false); |
5230 grand_child->SetDrawsContent(true); | 5253 grand_child->SetDrawsContent(true); |
5231 grand_child->SetHideLayerAndSubtree(true); | 5254 grand_child->SetHideLayerAndSubtree(true); |
5232 | 5255 |
5233 child->AddChild(std::move(grand_child)); | 5256 child->AddChild(std::move(grand_child)); |
5234 root->AddChild(std::move(child)); | 5257 root->AddChild(std::move(child)); |
5235 root->SetHasRenderSurface(true); | 5258 root->SetHasRenderSurface(true); |
5236 | 5259 |
5237 LayerImplList render_surface_layer_list; | 5260 LayerImplList render_surface_layer_list; |
| 5261 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
5238 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 5262 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
5239 root.get(), root->bounds(), &render_surface_layer_list); | 5263 root.get(), root->bounds(), &render_surface_layer_list, |
| 5264 root->layer_tree_impl()->current_render_surface_list_id()); |
5240 inputs.can_adjust_raster_scales = true; | 5265 inputs.can_adjust_raster_scales = true; |
5241 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 5266 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
5242 | 5267 |
5243 // We should have one render surface and two layers. The grand child has | 5268 // We should have one render surface and two layers. The grand child has |
5244 // hidden itself. | 5269 // hidden itself. |
5245 ASSERT_EQ(1u, render_surface_layer_list.size()); | 5270 ASSERT_EQ(1u, render_surface_layer_list.size()); |
5246 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); | 5271 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); |
5247 EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id()); | 5272 EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id()); |
5248 EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id()); | 5273 EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id()); |
5249 } | 5274 } |
(...skipping 24 matching lines...) Expand all Loading... |
5274 LayerImpl::Create(host_impl.pending_tree(), 3); | 5299 LayerImpl::Create(host_impl.pending_tree(), 3); |
5275 SetLayerPropertiesForTesting(grand_child.get(), identity_matrix, | 5300 SetLayerPropertiesForTesting(grand_child.get(), identity_matrix, |
5276 gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), | 5301 gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), |
5277 true, false, false); | 5302 true, false, false); |
5278 grand_child->SetDrawsContent(true); | 5303 grand_child->SetDrawsContent(true); |
5279 | 5304 |
5280 child->AddChild(std::move(grand_child)); | 5305 child->AddChild(std::move(grand_child)); |
5281 root->AddChild(std::move(child)); | 5306 root->AddChild(std::move(child)); |
5282 | 5307 |
5283 LayerImplList render_surface_layer_list; | 5308 LayerImplList render_surface_layer_list; |
| 5309 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
5284 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 5310 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
5285 root.get(), root->bounds(), &render_surface_layer_list); | 5311 root.get(), root->bounds(), &render_surface_layer_list, |
| 5312 root->layer_tree_impl()->current_render_surface_list_id()); |
5286 inputs.can_adjust_raster_scales = true; | 5313 inputs.can_adjust_raster_scales = true; |
5287 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 5314 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
5288 | 5315 |
5289 // We should have one render surface and one layers. The child has | 5316 // We should have one render surface and one layers. The child has |
5290 // hidden itself and the grand child. | 5317 // hidden itself and the grand child. |
5291 ASSERT_EQ(1u, render_surface_layer_list.size()); | 5318 ASSERT_EQ(1u, render_surface_layer_list.size()); |
5292 ASSERT_EQ(1u, root->render_surface()->layer_list().size()); | 5319 ASSERT_EQ(1u, root->render_surface()->layer_list().size()); |
5293 EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id()); | 5320 EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id()); |
5294 } | 5321 } |
5295 | 5322 |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5373 copy_grand_parent_sibling_before_layer->SetHideLayerAndSubtree(true); | 5400 copy_grand_parent_sibling_before_layer->SetHideLayerAndSubtree(true); |
5374 copy_grand_parent_sibling_after_layer->SetHideLayerAndSubtree(true); | 5401 copy_grand_parent_sibling_after_layer->SetHideLayerAndSubtree(true); |
5375 | 5402 |
5376 std::vector<scoped_ptr<CopyOutputRequest>> copy_requests; | 5403 std::vector<scoped_ptr<CopyOutputRequest>> copy_requests; |
5377 copy_requests.push_back( | 5404 copy_requests.push_back( |
5378 CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback))); | 5405 CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback))); |
5379 copy_layer->PassCopyRequests(©_requests); | 5406 copy_layer->PassCopyRequests(©_requests); |
5380 EXPECT_TRUE(copy_layer->HasCopyRequest()); | 5407 EXPECT_TRUE(copy_layer->HasCopyRequest()); |
5381 | 5408 |
5382 LayerImplList render_surface_layer_list; | 5409 LayerImplList render_surface_layer_list; |
| 5410 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
5383 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 5411 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
5384 root.get(), root->bounds(), &render_surface_layer_list); | 5412 root.get(), root->bounds(), &render_surface_layer_list, |
| 5413 root->layer_tree_impl()->current_render_surface_list_id()); |
5385 inputs.can_adjust_raster_scales = true; | 5414 inputs.can_adjust_raster_scales = true; |
5386 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 5415 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
5387 | 5416 |
5388 EXPECT_GT(root->num_layer_or_descendants_with_copy_request(), 0); | 5417 EXPECT_GT(root->num_layer_or_descendants_with_copy_request(), 0); |
5389 EXPECT_GT( | 5418 EXPECT_GT( |
5390 copy_grand_parent_layer->num_layer_or_descendants_with_copy_request(), 0); | 5419 copy_grand_parent_layer->num_layer_or_descendants_with_copy_request(), 0); |
5391 EXPECT_GT(copy_parent_layer->num_layer_or_descendants_with_copy_request(), 0); | 5420 EXPECT_GT(copy_parent_layer->num_layer_or_descendants_with_copy_request(), 0); |
5392 EXPECT_GT(copy_layer->num_layer_or_descendants_with_copy_request(), 0); | 5421 EXPECT_GT(copy_layer->num_layer_or_descendants_with_copy_request(), 0); |
5393 EXPECT_EQ(copy_child_layer->num_layer_or_descendants_with_copy_request(), 0); | 5422 EXPECT_EQ(copy_child_layer->num_layer_or_descendants_with_copy_request(), 0); |
5394 EXPECT_EQ(copy_grand_parent_sibling_before_layer | 5423 EXPECT_EQ(copy_grand_parent_sibling_before_layer |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5469 copy_requests.push_back( | 5498 copy_requests.push_back( |
5470 CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback))); | 5499 CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback))); |
5471 copy_layer->PassCopyRequests(©_requests); | 5500 copy_layer->PassCopyRequests(©_requests); |
5472 EXPECT_TRUE(copy_layer->HasCopyRequest()); | 5501 EXPECT_TRUE(copy_layer->HasCopyRequest()); |
5473 | 5502 |
5474 copy_layer->AddChild(std::move(copy_child)); | 5503 copy_layer->AddChild(std::move(copy_child)); |
5475 copy_parent->AddChild(std::move(copy_layer)); | 5504 copy_parent->AddChild(std::move(copy_layer)); |
5476 root->AddChild(std::move(copy_parent)); | 5505 root->AddChild(std::move(copy_parent)); |
5477 | 5506 |
5478 LayerImplList render_surface_layer_list; | 5507 LayerImplList render_surface_layer_list; |
| 5508 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
5479 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 5509 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
5480 root.get(), root->bounds(), &render_surface_layer_list); | 5510 root.get(), root->bounds(), &render_surface_layer_list, |
| 5511 root->layer_tree_impl()->current_render_surface_list_id()); |
5481 inputs.can_adjust_raster_scales = true; | 5512 inputs.can_adjust_raster_scales = true; |
5482 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 5513 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
5483 | 5514 |
5484 // We should have two render surface, as the others are clipped out. | 5515 // We should have two render surface, as the others are clipped out. |
5485 ASSERT_EQ(2u, render_surface_layer_list.size()); | 5516 ASSERT_EQ(2u, render_surface_layer_list.size()); |
5486 EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id()); | 5517 EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id()); |
5487 | 5518 |
5488 // The root render surface should only have 2 contributing layer, since the | 5519 // The root render surface should only have 2 contributing layer, since the |
5489 // other layers are empty/clipped away. | 5520 // other layers are empty/clipped away. |
5490 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); | 5521 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); |
(...skipping 549 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6040 child2->Set3dSortingContextId(1); | 6071 child2->Set3dSortingContextId(1); |
6041 child3->Set3dSortingContextId(1); | 6072 child3->Set3dSortingContextId(1); |
6042 | 6073 |
6043 child2->AddChild(std::move(child3)); | 6074 child2->AddChild(std::move(child3)); |
6044 child1->AddChild(std::move(child2)); | 6075 child1->AddChild(std::move(child2)); |
6045 root->AddChild(std::move(child1)); | 6076 root->AddChild(std::move(child1)); |
6046 | 6077 |
6047 { | 6078 { |
6048 LayerImplList render_surface_layer_list; | 6079 LayerImplList render_surface_layer_list; |
6049 FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get()); | 6080 FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get()); |
| 6081 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6050 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6082 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6051 root.get(), root->bounds(), &render_surface_layer_list); | 6083 root.get(), root->bounds(), &render_surface_layer_list, |
| 6084 root->layer_tree_impl()->current_render_surface_list_id()); |
6052 inputs.can_render_to_separate_surface = true; | 6085 inputs.can_render_to_separate_surface = true; |
6053 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6086 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6054 | 6087 |
6055 EXPECT_EQ(2u, render_surface_layer_list.size()); | 6088 EXPECT_EQ(2u, render_surface_layer_list.size()); |
6056 | 6089 |
6057 int count_represents_target_render_surface = 0; | 6090 int count_represents_target_render_surface = 0; |
6058 int count_represents_contributing_render_surface = 0; | 6091 int count_represents_contributing_render_surface = 0; |
6059 int count_represents_itself = 0; | 6092 int count_represents_itself = 0; |
6060 LayerIterator end = LayerIterator::End(&render_surface_layer_list); | 6093 LayerIterator end = LayerIterator::End(&render_surface_layer_list); |
6061 for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list); | 6094 for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list); |
6062 it != end; ++it) { | 6095 it != end; ++it) { |
6063 if (it.represents_target_render_surface()) | 6096 if (it.represents_target_render_surface()) |
6064 count_represents_target_render_surface++; | 6097 count_represents_target_render_surface++; |
6065 if (it.represents_contributing_render_surface()) | 6098 if (it.represents_contributing_render_surface()) |
6066 count_represents_contributing_render_surface++; | 6099 count_represents_contributing_render_surface++; |
6067 if (it.represents_itself()) | 6100 if (it.represents_itself()) |
6068 count_represents_itself++; | 6101 count_represents_itself++; |
6069 } | 6102 } |
6070 | 6103 |
6071 // Two render surfaces. | 6104 // Two render surfaces. |
6072 EXPECT_EQ(2, count_represents_target_render_surface); | 6105 EXPECT_EQ(2, count_represents_target_render_surface); |
6073 // Second render surface contributes to root render surface. | 6106 // Second render surface contributes to root render surface. |
6074 EXPECT_EQ(1, count_represents_contributing_render_surface); | 6107 EXPECT_EQ(1, count_represents_contributing_render_surface); |
6075 // All 4 layers represent itself. | 6108 // All 4 layers represent itself. |
6076 EXPECT_EQ(4, count_represents_itself); | 6109 EXPECT_EQ(4, count_represents_itself); |
6077 } | 6110 } |
6078 | 6111 |
6079 { | 6112 { |
6080 LayerImplList render_surface_layer_list; | 6113 LayerImplList render_surface_layer_list; |
| 6114 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6081 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6115 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6082 root.get(), root->bounds(), &render_surface_layer_list); | 6116 root.get(), root->bounds(), &render_surface_layer_list, |
| 6117 root->layer_tree_impl()->current_render_surface_list_id()); |
6083 inputs.can_render_to_separate_surface = false; | 6118 inputs.can_render_to_separate_surface = false; |
6084 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6119 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6085 | 6120 |
6086 EXPECT_EQ(1u, render_surface_layer_list.size()); | 6121 EXPECT_EQ(1u, render_surface_layer_list.size()); |
6087 | 6122 |
6088 int count_represents_target_render_surface = 0; | 6123 int count_represents_target_render_surface = 0; |
6089 int count_represents_contributing_render_surface = 0; | 6124 int count_represents_contributing_render_surface = 0; |
6090 int count_represents_itself = 0; | 6125 int count_represents_itself = 0; |
6091 LayerIterator end = LayerIterator::End(&render_surface_layer_list); | 6126 LayerIterator end = LayerIterator::End(&render_surface_layer_list); |
6092 for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list); | 6127 for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list); |
(...skipping 562 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6655 scroller->AddChild(std::move(fixed)); | 6690 scroller->AddChild(std::move(fixed)); |
6656 container->AddChild(std::move(scroller)); | 6691 container->AddChild(std::move(scroller)); |
6657 root->AddChild(std::move(container)); | 6692 root->AddChild(std::move(container)); |
6658 | 6693 |
6659 // Rounded to integers already. | 6694 // Rounded to integers already. |
6660 { | 6695 { |
6661 gfx::Vector2dF scroll_delta(3.0, 5.0); | 6696 gfx::Vector2dF scroll_delta(3.0, 5.0); |
6662 scroll_layer->SetScrollDelta(scroll_delta); | 6697 scroll_layer->SetScrollDelta(scroll_delta); |
6663 | 6698 |
6664 LayerImplList render_surface_layer_list; | 6699 LayerImplList render_surface_layer_list; |
| 6700 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6665 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6701 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6666 root.get(), root->bounds(), &render_surface_layer_list); | 6702 root.get(), root->bounds(), &render_surface_layer_list, |
| 6703 root->layer_tree_impl()->current_render_surface_list_id()); |
6667 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6704 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6668 | 6705 |
6669 EXPECT_TRANSFORMATION_MATRIX_EQ( | 6706 EXPECT_TRANSFORMATION_MATRIX_EQ( |
6670 container_layer->draw_properties().screen_space_transform, | 6707 container_layer->draw_properties().screen_space_transform, |
6671 fixed_layer->draw_properties().screen_space_transform); | 6708 fixed_layer->draw_properties().screen_space_transform); |
6672 EXPECT_VECTOR_EQ( | 6709 EXPECT_VECTOR_EQ( |
6673 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), | 6710 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), |
6674 container_offset); | 6711 container_offset); |
6675 EXPECT_VECTOR_EQ(scroll_layer->draw_properties() | 6712 EXPECT_VECTOR_EQ(scroll_layer->draw_properties() |
6676 .screen_space_transform.To2dTranslation(), | 6713 .screen_space_transform.To2dTranslation(), |
6677 container_offset - scroll_delta); | 6714 container_offset - scroll_delta); |
6678 } | 6715 } |
6679 | 6716 |
6680 // Scroll delta requiring rounding. | 6717 // Scroll delta requiring rounding. |
6681 { | 6718 { |
6682 gfx::Vector2dF scroll_delta(4.1f, 8.1f); | 6719 gfx::Vector2dF scroll_delta(4.1f, 8.1f); |
6683 scroll_layer->SetScrollDelta(scroll_delta); | 6720 scroll_layer->SetScrollDelta(scroll_delta); |
6684 | 6721 |
6685 gfx::Vector2dF rounded_scroll_delta(4.f, 8.f); | 6722 gfx::Vector2dF rounded_scroll_delta(4.f, 8.f); |
6686 | 6723 |
6687 LayerImplList render_surface_layer_list; | 6724 LayerImplList render_surface_layer_list; |
| 6725 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6688 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6726 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6689 root.get(), root->bounds(), &render_surface_layer_list); | 6727 root.get(), root->bounds(), &render_surface_layer_list, |
| 6728 root->layer_tree_impl()->current_render_surface_list_id()); |
6690 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6729 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6691 | 6730 |
6692 EXPECT_TRANSFORMATION_MATRIX_EQ( | 6731 EXPECT_TRANSFORMATION_MATRIX_EQ( |
6693 container_layer->draw_properties().screen_space_transform, | 6732 container_layer->draw_properties().screen_space_transform, |
6694 fixed_layer->draw_properties().screen_space_transform); | 6733 fixed_layer->draw_properties().screen_space_transform); |
6695 EXPECT_VECTOR_EQ( | 6734 EXPECT_VECTOR_EQ( |
6696 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), | 6735 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), |
6697 container_offset); | 6736 container_offset); |
6698 EXPECT_VECTOR_EQ(scroll_layer->draw_properties() | 6737 EXPECT_VECTOR_EQ(scroll_layer->draw_properties() |
6699 .screen_space_transform.To2dTranslation(), | 6738 .screen_space_transform.To2dTranslation(), |
6700 container_offset - rounded_scroll_delta); | 6739 container_offset - rounded_scroll_delta); |
6701 } | 6740 } |
6702 | 6741 |
6703 // Scale is applied earlier in the tree. | 6742 // Scale is applied earlier in the tree. |
6704 { | 6743 { |
6705 gfx::Transform scaled_container_transform = container_transform; | 6744 gfx::Transform scaled_container_transform = container_transform; |
6706 scaled_container_transform.Scale3d(2.0, 2.0, 1.0); | 6745 scaled_container_transform.Scale3d(2.0, 2.0, 1.0); |
6707 container_layer->SetTransform(scaled_container_transform); | 6746 container_layer->SetTransform(scaled_container_transform); |
6708 root->layer_tree_impl()->property_trees()->needs_rebuild = true; | 6747 root->layer_tree_impl()->property_trees()->needs_rebuild = true; |
6709 root->layer_tree_impl() | 6748 root->layer_tree_impl() |
6710 ->property_trees() | 6749 ->property_trees() |
6711 ->transform_tree.set_source_to_parent_updates_allowed(true); | 6750 ->transform_tree.set_source_to_parent_updates_allowed(true); |
6712 | 6751 |
6713 gfx::Vector2dF scroll_delta(4.5f, 8.5f); | 6752 gfx::Vector2dF scroll_delta(4.5f, 8.5f); |
6714 scroll_layer->SetScrollDelta(scroll_delta); | 6753 scroll_layer->SetScrollDelta(scroll_delta); |
6715 | 6754 |
6716 LayerImplList render_surface_layer_list; | 6755 LayerImplList render_surface_layer_list; |
| 6756 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6717 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6757 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6718 root.get(), root->bounds(), &render_surface_layer_list); | 6758 root.get(), root->bounds(), &render_surface_layer_list, |
| 6759 root->layer_tree_impl()->current_render_surface_list_id()); |
6719 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6760 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6720 | 6761 |
6721 EXPECT_TRANSFORMATION_MATRIX_EQ( | 6762 EXPECT_TRANSFORMATION_MATRIX_EQ( |
6722 container_layer->draw_properties().screen_space_transform, | 6763 container_layer->draw_properties().screen_space_transform, |
6723 fixed_layer->draw_properties().screen_space_transform); | 6764 fixed_layer->draw_properties().screen_space_transform); |
6724 EXPECT_VECTOR_EQ( | 6765 EXPECT_VECTOR_EQ( |
6725 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), | 6766 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), |
6726 container_offset); | 6767 container_offset); |
6727 | 6768 |
6728 container_layer->SetTransform(container_transform); | 6769 container_layer->SetTransform(container_transform); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6791 false, false); | 6832 false, false); |
6792 scroll_layer->PushScrollOffsetFromMainThread(scroll_offset); | 6833 scroll_layer->PushScrollOffsetFromMainThread(scroll_offset); |
6793 scroll_layer->SetScrollDelta(scroll_delta); | 6834 scroll_layer->SetScrollDelta(scroll_delta); |
6794 scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part); | 6835 scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part); |
6795 | 6836 |
6796 scroller->AddChild(std::move(fixed)); | 6837 scroller->AddChild(std::move(fixed)); |
6797 container->AddChild(std::move(scroller)); | 6838 container->AddChild(std::move(scroller)); |
6798 root->AddChild(std::move(container)); | 6839 root->AddChild(std::move(container)); |
6799 | 6840 |
6800 LayerImplList render_surface_layer_list; | 6841 LayerImplList render_surface_layer_list; |
| 6842 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
6801 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 6843 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
6802 root.get(), root->bounds(), &render_surface_layer_list); | 6844 root.get(), root->bounds(), &render_surface_layer_list, |
| 6845 root->layer_tree_impl()->current_render_surface_list_id()); |
6803 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 6846 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
6804 | 6847 |
6805 EXPECT_TRANSFORMATION_MATRIX_EQ( | 6848 EXPECT_TRANSFORMATION_MATRIX_EQ( |
6806 container_layer->draw_properties().screen_space_transform, | 6849 container_layer->draw_properties().screen_space_transform, |
6807 fixed_layer->draw_properties().screen_space_transform); | 6850 fixed_layer->draw_properties().screen_space_transform); |
6808 EXPECT_VECTOR_EQ( | 6851 EXPECT_VECTOR_EQ( |
6809 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), | 6852 fixed_layer->draw_properties().screen_space_transform.To2dTranslation(), |
6810 container_offset); | 6853 container_offset); |
6811 | 6854 |
6812 gfx::ScrollOffset effective_scroll_offset = | 6855 gfx::ScrollOffset effective_scroll_offset = |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6865 AddAnimatedTransformToLayer(animated_layer, 1.0, start_operations, | 6908 AddAnimatedTransformToLayer(animated_layer, 1.0, start_operations, |
6866 end_operations); | 6909 end_operations); |
6867 | 6910 |
6868 gfx::Vector2dF scroll_delta(5.f, 9.f); | 6911 gfx::Vector2dF scroll_delta(5.f, 9.f); |
6869 scroller->SetScrollDelta(scroll_delta); | 6912 scroller->SetScrollDelta(scroll_delta); |
6870 | 6913 |
6871 ExecuteCalculateDrawProperties(root); | 6914 ExecuteCalculateDrawProperties(root); |
6872 | 6915 |
6873 gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f); | 6916 gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f); |
6874 EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation, | 6917 EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation, |
6875 scroller->draw_transform().To2dTranslation()); | 6918 scroller->DrawTransform().To2dTranslation()); |
6876 } | 6919 } |
6877 | 6920 |
6878 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl { | 6921 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl { |
6879 public: | 6922 public: |
6880 static scoped_ptr<AnimationScaleFactorTrackingLayerImpl> Create( | 6923 static scoped_ptr<AnimationScaleFactorTrackingLayerImpl> Create( |
6881 LayerTreeImpl* tree_impl, | 6924 LayerTreeImpl* tree_impl, |
6882 int id) { | 6925 int id) { |
6883 return make_scoped_ptr( | 6926 return make_scoped_ptr( |
6884 new AnimationScaleFactorTrackingLayerImpl(tree_impl, id)); | 6927 new AnimationScaleFactorTrackingLayerImpl(tree_impl, id)); |
6885 } | 6928 } |
(...skipping 666 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7552 | 7595 |
7553 // Changing page-scale would affect ideal_contents_scale and | 7596 // Changing page-scale would affect ideal_contents_scale and |
7554 // maximum_animation_contents_scale. | 7597 // maximum_animation_contents_scale. |
7555 | 7598 |
7556 float page_scale_factor = 3.f; | 7599 float page_scale_factor = 3.f; |
7557 float device_scale_factor = 1.0f; | 7600 float device_scale_factor = 1.0f; |
7558 std::vector<LayerImpl*> render_surface_layer_list; | 7601 std::vector<LayerImpl*> render_surface_layer_list; |
7559 gfx::Size device_viewport_size = | 7602 gfx::Size device_viewport_size = |
7560 gfx::Size(root_layer->bounds().width() * device_scale_factor, | 7603 gfx::Size(root_layer->bounds().width() * device_scale_factor, |
7561 root_layer->bounds().height() * device_scale_factor); | 7604 root_layer->bounds().height() * device_scale_factor); |
| 7605 root_layer->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
7562 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 7606 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
7563 root_layer, device_viewport_size, &render_surface_layer_list); | 7607 root_layer, device_viewport_size, &render_surface_layer_list, |
| 7608 root_layer->layer_tree_impl()->current_render_surface_list_id()); |
7564 | 7609 |
7565 inputs.page_scale_factor = page_scale_factor; | 7610 inputs.page_scale_factor = page_scale_factor; |
7566 inputs.can_adjust_raster_scales = true; | 7611 inputs.can_adjust_raster_scales = true; |
7567 inputs.page_scale_layer = root_layer; | 7612 inputs.page_scale_layer = root_layer; |
7568 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 7613 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
7569 | 7614 |
7570 EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale()); | 7615 EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale()); |
7571 EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale()); | 7616 EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale()); |
7572 EXPECT_FLOAT_EQ(9.f, child1_layer->mask_layer()->GetIdealContentsScale()); | 7617 EXPECT_FLOAT_EQ(9.f, child1_layer->mask_layer()->GetIdealContentsScale()); |
7573 EXPECT_FLOAT_EQ( | 7618 EXPECT_FLOAT_EQ( |
(...skipping 148 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7722 identity_matrix, | 7767 identity_matrix, |
7723 gfx::Point3F(), | 7768 gfx::Point3F(), |
7724 gfx::PointF(), | 7769 gfx::PointF(), |
7725 sublayer_size, | 7770 sublayer_size, |
7726 false, | 7771 false, |
7727 false, | 7772 false, |
7728 false); | 7773 false); |
7729 sublayer->SetDrawsContent(true); | 7774 sublayer->SetDrawsContent(true); |
7730 | 7775 |
7731 LayerImplList layer_impl_list; | 7776 LayerImplList layer_impl_list; |
| 7777 root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting(); |
7732 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | 7778 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( |
7733 root, device_viewport_size, &layer_impl_list); | 7779 root, device_viewport_size, &layer_impl_list, |
| 7780 root->layer_tree_impl()->current_render_surface_list_id()); |
7734 | 7781 |
7735 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 7782 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
7736 EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect()); | 7783 EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect()); |
7737 | 7784 |
7738 root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0)); | 7785 root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0)); |
7739 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 7786 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
7740 | 7787 |
7741 gfx::Rect affected_by_delta(0, 0, root_size.width(), | 7788 gfx::Rect affected_by_delta(0, 0, root_size.width(), |
7742 root_size.height() + 50); | 7789 root_size.height() + 50); |
7743 EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect()); | 7790 EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect()); |
(...skipping 1525 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9269 bool root_in_rsll = | 9316 bool root_in_rsll = |
9270 std::find(rsll->begin(), rsll->end(), root) != rsll->end(); | 9317 std::find(rsll->begin(), rsll->end(), root) != rsll->end(); |
9271 EXPECT_TRUE(root_in_rsll); | 9318 EXPECT_TRUE(root_in_rsll); |
9272 bool render_surface2_in_rsll = | 9319 bool render_surface2_in_rsll = |
9273 std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end(); | 9320 std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end(); |
9274 EXPECT_FALSE(render_surface2_in_rsll); | 9321 EXPECT_FALSE(render_surface2_in_rsll); |
9275 } | 9322 } |
9276 | 9323 |
9277 } // namespace | 9324 } // namespace |
9278 } // namespace cc | 9325 } // namespace cc |
OLD | NEW |