OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/draw_property_utils.h" | 5 #include "cc/trees/draw_property_utils.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
102 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space | 102 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space |
103 : clip_node->clip_in_target_space; | 103 : clip_node->clip_in_target_space; |
104 | 104 |
105 if (clip_node->target_transform_id > target_node_id) { | 105 if (clip_node->target_transform_id > target_node_id) { |
106 // In this case, layer has a scroll parent. We need to keep the scale | 106 // In this case, layer has a scroll parent. We need to keep the scale |
107 // at the layer's target but remove the scale at the scroll parent's | 107 // at the layer's target but remove the scale at the scroll parent's |
108 // target. | 108 // target. |
109 if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id, | 109 if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id, |
110 target_effect_node->id, | 110 target_effect_node->id, |
111 &clip_to_target)) { | 111 &clip_to_target)) { |
112 // We don't have to apply surface contents scale when target is root. | 112 PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target); |
113 if (target_effect_node->id != EffectTree::kContentsRootNodeId) { | |
114 PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target); | |
115 #if DCHECK_IS_ON() | 113 #if DCHECK_IS_ON() |
116 const TransformTree& transform_tree = property_trees->transform_tree; | 114 const TransformTree& transform_tree = property_trees->transform_tree; |
117 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), | 115 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), |
118 target_node_id, effect_tree, | 116 target_node_id, effect_tree, |
119 transform_tree); | 117 transform_tree); |
120 #endif | 118 #endif |
121 } | |
122 | 119 |
123 const EffectNode* source_node = | 120 const EffectNode* source_node = |
124 effect_tree.Node(clip_node->target_effect_id); | 121 effect_tree.Node(clip_node->target_effect_id); |
125 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target); | 122 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target); |
126 #if DCHECK_IS_ON() | 123 #if DCHECK_IS_ON() |
127 const TransformTree& transform_tree = property_trees->transform_tree; | |
128 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 124 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
129 clip_node->target_transform_id, | 125 clip_node->target_transform_id, |
130 effect_tree, transform_tree); | 126 effect_tree, transform_tree); |
131 #endif | 127 #endif |
132 *clip_rect_in_target_space = | 128 *clip_rect_in_target_space = |
133 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node); | 129 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node); |
134 } else { | 130 } else { |
135 return false; | 131 return false; |
136 } | 132 } |
137 } else { | 133 } else { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 } | 172 } |
177 | 173 |
178 static ConditionalClip ComputeLocalRectInTargetSpace( | 174 static ConditionalClip ComputeLocalRectInTargetSpace( |
179 gfx::RectF rect, | 175 gfx::RectF rect, |
180 const PropertyTrees* property_trees, | 176 const PropertyTrees* property_trees, |
181 int current_transform_id, | 177 int current_transform_id, |
182 int target_transform_id, | 178 int target_transform_id, |
183 int target_effect_id) { | 179 int target_effect_id) { |
184 gfx::Transform current_to_target; | 180 gfx::Transform current_to_target; |
185 if (!property_trees->ComputeTransformToTarget( | 181 if (!property_trees->ComputeTransformToTarget( |
186 current_transform_id, target_effect_id, ¤t_to_target)) | 182 current_transform_id, target_effect_id, ¤t_to_target)) { |
187 // If transform is not invertible, cannot apply clip. | 183 // If transform is not invertible, cannot apply clip. |
188 return ConditionalClip{false, gfx::RectF()}; | 184 return ConditionalClip{false, gfx::RectF()}; |
189 // We don't have to apply surface contents scale when target is root. | 185 } |
190 if (target_effect_id != EffectTree::kContentsRootNodeId) { | 186 const EffectTree& effect_tree = property_trees->effect_tree; |
191 const EffectTree& effect_tree = property_trees->effect_tree; | 187 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id); |
192 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id); | 188 PostConcatSurfaceContentsScale(target_effect_node, ¤t_to_target); |
193 PostConcatSurfaceContentsScale(target_effect_node, ¤t_to_target); | |
194 #if DCHECK_IS_ON() | 189 #if DCHECK_IS_ON() |
195 const TransformTree& transform_tree = property_trees->transform_tree; | 190 const TransformTree& transform_tree = property_trees->transform_tree; |
196 VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id, | 191 VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id, |
197 effect_tree, transform_tree); | 192 effect_tree, transform_tree); |
198 #endif | 193 #endif |
199 } | |
200 | 194 |
201 if (current_transform_id > target_transform_id) | 195 if (current_transform_id > target_transform_id) |
202 return ConditionalClip{true, // is_clipped. | 196 return ConditionalClip{true, // is_clipped. |
203 MathUtil::MapClippedRect(current_to_target, rect)}; | 197 MathUtil::MapClippedRect(current_to_target, rect)}; |
204 | 198 |
205 return ConditionalClip{true, // is_clipped. | 199 return ConditionalClip{true, // is_clipped. |
206 MathUtil::ProjectClippedRect(current_to_target, rect)}; | 200 MathUtil::ProjectClippedRect(current_to_target, rect)}; |
207 } | 201 } |
208 | 202 |
209 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, | 203 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, |
(...skipping 323 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
533 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree); | 527 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree); |
534 bool success = property_trees->ComputeTransformFromTarget( | 528 bool success = property_trees->ComputeTransformFromTarget( |
535 transform_node->id, target_effect_node->id, &target_to_layer); | 529 transform_node->id, target_effect_node->id, &target_to_layer); |
536 if (!success) { | 530 if (!success) { |
537 // An animated singular transform may become non-singular during the | 531 // An animated singular transform may become non-singular during the |
538 // animation, so we still need to compute a visible rect. In this | 532 // animation, so we still need to compute a visible rect. In this |
539 // situation, we treat the entire layer as visible. | 533 // situation, we treat the entire layer as visible. |
540 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 534 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
541 continue; | 535 continue; |
542 } | 536 } |
543 if (target_effect_node->id > EffectTree::kContentsRootNodeId) { | 537 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer); |
544 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer); | |
545 #if DCHECK_IS_ON() | 538 #if DCHECK_IS_ON() |
546 VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id, | 539 VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id, |
547 effect_tree, transform_tree); | 540 effect_tree, transform_tree); |
548 #endif | 541 #endif |
549 } | |
550 } | 542 } |
551 gfx::Transform target_to_content; | 543 gfx::Transform target_to_content; |
552 target_to_content.Translate(-layer->offset_to_transform_parent().x(), | 544 target_to_content.Translate(-layer->offset_to_transform_parent().x(), |
553 -layer->offset_to_transform_parent().y()); | 545 -layer->offset_to_transform_parent().y()); |
554 target_to_content.PreconcatTransform(target_to_layer); | 546 target_to_content.PreconcatTransform(target_to_layer); |
555 | 547 |
556 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 548 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
557 target_to_content, combined_clip_rect_in_target_space)); | 549 target_to_content, combined_clip_rect_in_target_space)); |
558 visible_rect.Intersect(gfx::Rect(layer_bounds)); | 550 visible_rect.Intersect(gfx::Rect(layer_bounds)); |
559 layer->set_visible_layer_rect(visible_rect); | 551 layer->set_visible_layer_rect(visible_rect); |
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
818 gfx::RectF parent_combined_clip_in_target_space = | 810 gfx::RectF parent_combined_clip_in_target_space = |
819 parent_clip_node->combined_clip_in_target_space; | 811 parent_clip_node->combined_clip_in_target_space; |
820 gfx::RectF parent_clip_in_target_space = | 812 gfx::RectF parent_clip_in_target_space = |
821 parent_clip_node->clip_in_target_space; | 813 parent_clip_node->clip_in_target_space; |
822 if (parent_target_transform_node && | 814 if (parent_target_transform_node && |
823 parent_target_transform_node->id != clip_node->target_transform_id && | 815 parent_target_transform_node->id != clip_node->target_transform_id && |
824 non_root_surfaces_enabled) { | 816 non_root_surfaces_enabled) { |
825 success &= property_trees->ComputeTransformFromTarget( | 817 success &= property_trees->ComputeTransformFromTarget( |
826 clip_node->target_transform_id, parent_clip_node->target_effect_id, | 818 clip_node->target_transform_id, parent_clip_node->target_effect_id, |
827 &parent_to_current); | 819 &parent_to_current); |
828 // We don't have to apply surface contents scale when target is root. | 820 const EffectNode* target_effect_node = |
829 if (clip_node->target_effect_id != EffectTree::kContentsRootNodeId) { | 821 effect_tree.Node(clip_node->target_effect_id); |
830 const EffectNode* target_effect_node = | 822 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current); |
831 effect_tree.Node(clip_node->target_effect_id); | |
832 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current); | |
833 #if DCHECK_IS_ON() | 823 #if DCHECK_IS_ON() |
834 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 824 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
835 clip_node->target_transform_id, | 825 clip_node->target_transform_id, |
836 effect_tree, transform_tree); | 826 effect_tree, transform_tree); |
837 #endif | 827 #endif |
838 } | 828 const EffectNode* parent_target_effect_node = |
839 if (parent_clip_node->target_effect_id != | 829 effect_tree.Node(parent_clip_node->target_effect_id); |
840 EffectTree::kContentsRootNodeId) { | 830 ConcatInverseSurfaceContentsScale(parent_target_effect_node, |
841 const EffectNode* parent_target_effect_node = | 831 &parent_to_current); |
842 effect_tree.Node(parent_clip_node->target_effect_id); | |
843 ConcatInverseSurfaceContentsScale(parent_target_effect_node, | |
844 &parent_to_current); | |
845 #if DCHECK_IS_ON() | 832 #if DCHECK_IS_ON() |
846 VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id, | 833 VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id, |
847 parent_clip_node->target_transform_id, | 834 parent_clip_node->target_transform_id, |
848 effect_tree, transform_tree); | 835 effect_tree, transform_tree); |
849 #endif | 836 #endif |
850 } | |
851 // If we can't compute a transform, it's because we had to use the inverse | 837 // If we can't compute a transform, it's because we had to use the inverse |
852 // of a singular transform. We won't draw in this case, so there's no need | 838 // of a singular transform. We won't draw in this case, so there's no need |
853 // to compute clips. | 839 // to compute clips. |
854 if (!success) | 840 if (!success) |
855 continue; | 841 continue; |
856 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( | 842 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( |
857 parent_to_current, parent_clip_node->combined_clip_in_target_space); | 843 parent_to_current, parent_clip_node->combined_clip_in_target_space); |
858 parent_clip_in_target_space = MathUtil::ProjectClippedRect( | 844 parent_clip_in_target_space = MathUtil::ProjectClippedRect( |
859 parent_to_current, parent_clip_node->clip_in_target_space); | 845 parent_to_current, parent_clip_node->clip_in_target_space); |
860 } | 846 } |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
902 | 888 |
903 if (!non_root_surfaces_enabled) { | 889 if (!non_root_surfaces_enabled) { |
904 source_to_target = transform_tree.ToScreen(clip_node->transform_id); | 890 source_to_target = transform_tree.ToScreen(clip_node->transform_id); |
905 } else if (transform_tree.ContentTargetId(transform_node->id) == | 891 } else if (transform_tree.ContentTargetId(transform_node->id) == |
906 clip_node->target_transform_id) { | 892 clip_node->target_transform_id) { |
907 source_to_target = transform_tree.ToTarget(clip_node->transform_id, | 893 source_to_target = transform_tree.ToTarget(clip_node->transform_id, |
908 clip_node->target_effect_id); | 894 clip_node->target_effect_id); |
909 } else { | 895 } else { |
910 success = property_trees->ComputeTransformToTarget( | 896 success = property_trees->ComputeTransformToTarget( |
911 transform_node->id, clip_node->target_effect_id, &source_to_target); | 897 transform_node->id, clip_node->target_effect_id, &source_to_target); |
912 // We don't have to apply surface contents scale when target is root. | 898 const EffectNode* target_effect_node = |
913 if (clip_node->target_effect_id != EffectTree::kContentsRootNodeId) { | 899 effect_tree.Node(clip_node->target_effect_id); |
914 const EffectNode* target_effect_node = | 900 PostConcatSurfaceContentsScale(target_effect_node, &source_to_target); |
915 effect_tree.Node(clip_node->target_effect_id); | |
916 PostConcatSurfaceContentsScale(target_effect_node, &source_to_target); | |
917 #if DCHECK_IS_ON() | 901 #if DCHECK_IS_ON() |
918 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 902 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
919 clip_node->target_transform_id, | 903 clip_node->target_transform_id, |
920 effect_tree, transform_tree); | 904 effect_tree, transform_tree); |
921 #endif | 905 #endif |
922 } | |
923 // source_to_target computation should be successful as target is an | 906 // source_to_target computation should be successful as target is an |
924 // ancestor of the transform node. | 907 // ancestor of the transform node. |
925 DCHECK(success); | 908 DCHECK(success); |
926 } | 909 } |
927 | 910 |
928 gfx::RectF source_clip_in_target_space = | 911 gfx::RectF source_clip_in_target_space = |
929 MathUtil::MapClippedRect(source_to_target, clip_node->clip); | 912 MathUtil::MapClippedRect(source_to_target, clip_node->clip); |
930 | 913 |
931 // With surfaces disabled, the only case where we use only the local clip | 914 // With surfaces disabled, the only case where we use only the local clip |
932 // for layer clipping is the case where no non-viewport ancestor node | 915 // for layer clipping is the case where no non-viewport ancestor node |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1063 static void VerifyDrawTransformsMatch(LayerImpl* layer, | 1046 static void VerifyDrawTransformsMatch(LayerImpl* layer, |
1064 PropertyTrees* property_trees) { | 1047 PropertyTrees* property_trees) { |
1065 const int source_id = layer->transform_tree_index(); | 1048 const int source_id = layer->transform_tree_index(); |
1066 int destination_id = FindTargetTransformTreeIndexFromEffectTree( | 1049 int destination_id = FindTargetTransformTreeIndexFromEffectTree( |
1067 property_trees->effect_tree, layer->effect_tree_index()); | 1050 property_trees->effect_tree, layer->effect_tree_index()); |
1068 const EffectNode* target_effect_node = ContentsTargetEffectNode( | 1051 const EffectNode* target_effect_node = ContentsTargetEffectNode( |
1069 layer->effect_tree_index(), property_trees->effect_tree); | 1052 layer->effect_tree_index(), property_trees->effect_tree); |
1070 gfx::Transform draw_transform; | 1053 gfx::Transform draw_transform; |
1071 property_trees->ComputeTransformToTarget(source_id, target_effect_node->id, | 1054 property_trees->ComputeTransformToTarget(source_id, target_effect_node->id, |
1072 &draw_transform); | 1055 &draw_transform); |
1073 // We don't have to apply surface contents scale when target is root. | 1056 PostConcatSurfaceContentsScale(target_effect_node, &draw_transform); |
1074 if (target_effect_node->id != EffectTree::kContentsRootNodeId) { | |
1075 PostConcatSurfaceContentsScale(target_effect_node, &draw_transform); | |
1076 #if DCHECK_IS_ON() | 1057 #if DCHECK_IS_ON() |
1077 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id, | 1058 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id, |
1078 property_trees->effect_tree, | 1059 property_trees->effect_tree, |
1079 property_trees->transform_tree); | 1060 property_trees->transform_tree); |
1080 #endif | 1061 #endif |
1081 } | |
1082 if (layer->should_flatten_transform_from_property_tree()) | 1062 if (layer->should_flatten_transform_from_property_tree()) |
1083 draw_transform.FlattenTo2d(); | 1063 draw_transform.FlattenTo2d(); |
1084 draw_transform.Translate(layer->offset_to_transform_parent().x(), | 1064 draw_transform.Translate(layer->offset_to_transform_parent().x(), |
1085 layer->offset_to_transform_parent().y()); | 1065 layer->offset_to_transform_parent().y()); |
1086 DCHECK(draw_transform.ApproximatelyEqual(DrawTransform( | 1066 DCHECK(draw_transform.ApproximatelyEqual(DrawTransform( |
1087 layer, property_trees->transform_tree, property_trees->effect_tree))) | 1067 layer, property_trees->transform_tree, property_trees->effect_tree))) |
1088 << " layer: " << layer->id() << " source transform id: " << source_id | 1068 << " layer: " << layer->id() << " source transform id: " << source_id |
1089 << " destination transform id: " << destination_id | 1069 << " destination transform id: " << destination_id |
1090 << " draw transform from transform tree: " | 1070 << " draw transform from transform tree: " |
1091 << DrawTransform(layer, property_trees->transform_tree, | 1071 << DrawTransform(layer, property_trees->transform_tree, |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1313 if (transform_node->id == 1) { | 1293 if (transform_node->id == 1) { |
1314 render_surface->SetDrawTransform(gfx::Transform()); | 1294 render_surface->SetDrawTransform(gfx::Transform()); |
1315 return; | 1295 return; |
1316 } | 1296 } |
1317 | 1297 |
1318 gfx::Transform render_surface_transform; | 1298 gfx::Transform render_surface_transform; |
1319 const EffectNode* target_effect_node = | 1299 const EffectNode* target_effect_node = |
1320 effect_tree.Node(effect_node->target_id); | 1300 effect_tree.Node(effect_node->target_id); |
1321 property_trees->ComputeTransformToTarget( | 1301 property_trees->ComputeTransformToTarget( |
1322 transform_node->id, target_effect_node->id, &render_surface_transform); | 1302 transform_node->id, target_effect_node->id, &render_surface_transform); |
1323 // We don't have to apply surface contents scale when target is root. | 1303 PostConcatSurfaceContentsScale(target_effect_node, &render_surface_transform); |
1324 if (effect_node->target_id != EffectTree::kContentsRootNodeId) { | |
1325 PostConcatSurfaceContentsScale(target_effect_node, | |
1326 &render_surface_transform); | |
1327 #if DCHECK_IS_ON() | 1304 #if DCHECK_IS_ON() |
1328 const TransformNode* target_transform_node = | 1305 const TransformNode* target_transform_node = |
1329 transform_tree.Node(transform_tree.TargetId(transform_node->id)); | 1306 transform_tree.Node(transform_tree.TargetId(transform_node->id)); |
1330 VerifySurfaceContentsScalesMatch(effect_node->target_id, | 1307 VerifySurfaceContentsScalesMatch(effect_node->target_id, |
1331 target_transform_node->id, effect_tree, | 1308 target_transform_node->id, effect_tree, |
1332 transform_tree); | 1309 transform_tree); |
1333 #endif | 1310 #endif |
1334 } | |
1335 | 1311 |
1336 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform); | 1312 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform); |
1337 #if DCHECK_IS_ON() | 1313 #if DCHECK_IS_ON() |
1338 VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id, | 1314 VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id, |
1339 effect_tree, transform_tree); | 1315 effect_tree, transform_tree); |
1340 #endif | 1316 #endif |
1341 render_surface->SetDrawTransform(render_surface_transform); | 1317 render_surface->SetDrawTransform(render_surface_transform); |
1342 } | 1318 } |
1343 | 1319 |
1344 static void SetSurfaceIsClipped(const ClipNode* clip_node, | 1320 static void SetSurfaceIsClipped(const ClipNode* clip_node, |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1377 int target_effect_id = effect_node->target_id; | 1353 int target_effect_id = effect_node->target_id; |
1378 const bool success = property_trees->ComputeTransformToTarget( | 1354 const bool success = property_trees->ComputeTransformToTarget( |
1379 parent_clip_node->target_transform_id, target_effect_id, | 1355 parent_clip_node->target_transform_id, target_effect_id, |
1380 &clip_parent_target_to_target); | 1356 &clip_parent_target_to_target); |
1381 | 1357 |
1382 if (!success) { | 1358 if (!success) { |
1383 render_surface->SetClipRect(gfx::Rect()); | 1359 render_surface->SetClipRect(gfx::Rect()); |
1384 return; | 1360 return; |
1385 } | 1361 } |
1386 | 1362 |
1387 // We don't have to apply surface contents scale when target is root. | 1363 PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target); |
1388 if (render_surface->EffectTreeIndex() != EffectTree::kContentsRootNodeId) { | |
1389 const EffectNode* effect_node = | |
1390 effect_tree.Node(render_surface->EffectTreeIndex()); | |
1391 PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target); | |
1392 #if DCHECK_IS_ON() | 1364 #if DCHECK_IS_ON() |
1393 VerifySurfaceContentsScalesMatch( | 1365 VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(), |
1394 render_surface->EffectTreeIndex(), | 1366 transform_tree.TargetId(transform_node->id), |
1395 transform_tree.TargetId(transform_node->id), effect_tree, | 1367 effect_tree, transform_tree); |
1396 transform_tree); | |
1397 #endif | 1368 #endif |
1398 } | |
1399 | 1369 |
1400 DCHECK_LT(parent_clip_node->target_transform_id, | 1370 DCHECK_LT(parent_clip_node->target_transform_id, |
1401 transform_tree.TargetId(transform_node->id)); | 1371 transform_tree.TargetId(transform_node->id)); |
1402 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 1372 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
1403 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); | 1373 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); |
1404 } | 1374 } |
1405 | 1375 |
1406 template <typename LayerType> | 1376 template <typename LayerType> |
1407 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, | 1377 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, |
1408 const TransformTree& tree) { | 1378 const TransformTree& tree) { |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1620 void UpdateElasticOverscroll(PropertyTrees* property_trees, | 1590 void UpdateElasticOverscroll(PropertyTrees* property_trees, |
1621 const Layer* overscroll_elasticity_layer, | 1591 const Layer* overscroll_elasticity_layer, |
1622 const gfx::Vector2dF& elastic_overscroll) { | 1592 const gfx::Vector2dF& elastic_overscroll) { |
1623 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, | 1593 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, |
1624 elastic_overscroll); | 1594 elastic_overscroll); |
1625 } | 1595 } |
1626 | 1596 |
1627 } // namespace draw_property_utils | 1597 } // namespace draw_property_utils |
1628 | 1598 |
1629 } // namespace cc | 1599 } // namespace cc |
OLD | NEW |