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

Side by Side Diff: cc/trees/draw_property_utils.cc

Issue 2448403002: cc: Clean up transform tree (Closed)
Patch Set: PAC Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/trees/draw_property_utils.h ('k') | cc/trees/layer_tree_host_common.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
46 EffectNode* effect_node = 46 EffectNode* effect_node =
47 layer->layer_tree_impl()->property_trees()->effect_tree.Node( 47 layer->layer_tree_impl()->property_trees()->effect_tree.Node(
48 layer->effect_tree_index()); 48 layer->effect_tree_index());
49 if (effect_node->owner_id != layer->id()) 49 if (effect_node->owner_id != layer->id())
50 return; 50 return;
51 DCHECK_EQ(effect_node->mask_layer_id, EffectTree::kInvalidNodeId) 51 DCHECK_EQ(effect_node->mask_layer_id, EffectTree::kInvalidNodeId)
52 << "layer: " << layer->id(); 52 << "layer: " << layer->id();
53 DCHECK(effect_node->filters.IsEmpty()); 53 DCHECK(effect_node->filters.IsEmpty());
54 DCHECK(effect_node->background_filters.IsEmpty()); 54 DCHECK(effect_node->background_filters.IsEmpty());
55 } 55 }
56
57 void VerifySurfaceContentsScalesMatch(const int target_effect_id,
58 const int target_transform_id,
59 const EffectTree& effect_tree,
60 const TransformTree& transform_tree) {
61 if (target_effect_id == EffectTree::kInvalidNodeId) {
62 // This can happen when PaintArtifactCompositor builds property trees as it
63 // doesn't set effect ids on clip nodes.
64 return;
65 }
66 const TransformNode* target_transform_node =
67 transform_tree.Node(target_transform_id);
68 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
69 DCHECK(target_transform_node->surface_contents_scale ==
70 target_effect_node->surface_contents_scale)
71 << " surface contents scale from transform tree: "
72 << target_transform_node->surface_contents_scale.ToString()
73 << " surface contents scale from effect tree: "
74 << target_effect_node->surface_contents_scale.ToString();
75 }
76 #endif 56 #endif
77 57
78 static const EffectNode* ContentsTargetEffectNode( 58 static const EffectNode* ContentsTargetEffectNode(
79 const int effect_tree_index, 59 const int effect_tree_index,
80 const EffectTree& effect_tree) { 60 const EffectTree& effect_tree) {
81 const EffectNode* effect_node = effect_tree.Node(effect_tree_index); 61 const EffectNode* effect_node = effect_tree.Node(effect_tree_index);
82 return effect_node->render_surface ? effect_node 62 return effect_node->render_surface ? effect_node
83 : effect_tree.Node(effect_node->target_id); 63 : effect_tree.Node(effect_node->target_id);
84 } 64 }
85 65
(...skipping 13 matching lines...) Expand all
99 // We use the local clip for clip rect calculation and combined clip for 79 // We use the local clip for clip rect calculation and combined clip for
100 // visible rect calculation. 80 // visible rect calculation.
101 gfx::RectF clip_from_clip_node = 81 gfx::RectF clip_from_clip_node =
102 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space 82 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space
103 : clip_node->clip_in_target_space; 83 : clip_node->clip_in_target_space;
104 84
105 if (clip_node->target_transform_id > target_node_id) { 85 if (clip_node->target_transform_id > target_node_id) {
106 // In this case, layer has a scroll parent. We need to keep the scale 86 // 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 87 // at the layer's target but remove the scale at the scroll parent's
108 // target. 88 // target.
109 if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id, 89 if (property_trees->GetToTarget(clip_node->target_transform_id,
110 target_effect_node->id, 90 target_effect_node->id, &clip_to_target)) {
111 &clip_to_target)) {
112 PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
113 #if DCHECK_IS_ON()
114 const TransformTree& transform_tree = property_trees->transform_tree;
115 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
116 target_node_id, effect_tree,
117 transform_tree);
118 #endif
119
120 const EffectNode* source_node = 91 const EffectNode* source_node =
121 effect_tree.Node(clip_node->target_effect_id); 92 effect_tree.Node(clip_node->target_effect_id);
122 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target); 93 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target);
123 #if DCHECK_IS_ON()
124 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
125 clip_node->target_transform_id,
126 effect_tree, transform_tree);
127 #endif
128 *clip_rect_in_target_space = 94 *clip_rect_in_target_space =
129 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node); 95 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node);
130 } else { 96 } else {
131 return false; 97 return false;
132 } 98 }
133 } else { 99 } else {
134 if (property_trees->ComputeTransformFromTarget( 100 if (property_trees->ComputeTransformFromTarget(
135 target_node_id, clip_node->target_effect_id, &clip_to_target)) { 101 target_node_id, clip_node->target_effect_id, &clip_to_target)) {
136 *clip_rect_in_target_space = 102 *clip_rect_in_target_space =
137 MathUtil::ProjectClippedRect(clip_to_target, clip_from_clip_node); 103 MathUtil::ProjectClippedRect(clip_to_target, clip_from_clip_node);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
171 MathUtil::ProjectClippedRect(target_to_local, rect)}; 137 MathUtil::ProjectClippedRect(target_to_local, rect)};
172 } 138 }
173 139
174 static ConditionalClip ComputeLocalRectInTargetSpace( 140 static ConditionalClip ComputeLocalRectInTargetSpace(
175 gfx::RectF rect, 141 gfx::RectF rect,
176 const PropertyTrees* property_trees, 142 const PropertyTrees* property_trees,
177 int current_transform_id, 143 int current_transform_id,
178 int target_transform_id, 144 int target_transform_id,
179 int target_effect_id) { 145 int target_effect_id) {
180 gfx::Transform current_to_target; 146 gfx::Transform current_to_target;
181 if (!property_trees->ComputeTransformToTarget( 147 if (!property_trees->GetToTarget(current_transform_id, target_effect_id,
182 current_transform_id, target_effect_id, &current_to_target)) { 148 &current_to_target)) {
183 // If transform is not invertible, cannot apply clip. 149 // If transform is not invertible, cannot apply clip.
184 return ConditionalClip{false, gfx::RectF()}; 150 return ConditionalClip{false, gfx::RectF()};
185 } 151 }
186 const EffectTree& effect_tree = property_trees->effect_tree;
187 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
188 PostConcatSurfaceContentsScale(target_effect_node, &current_to_target);
189 #if DCHECK_IS_ON()
190 const TransformTree& transform_tree = property_trees->transform_tree;
191 VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id,
192 effect_tree, transform_tree);
193 #endif
194 152
195 if (current_transform_id > target_transform_id) 153 if (current_transform_id > target_transform_id)
196 return ConditionalClip{true, // is_clipped. 154 return ConditionalClip{true, // is_clipped.
197 MathUtil::MapClippedRect(current_to_target, rect)}; 155 MathUtil::MapClippedRect(current_to_target, rect)};
198 156
199 return ConditionalClip{true, // is_clipped. 157 return ConditionalClip{true, // is_clipped.
200 MathUtil::ProjectClippedRect(current_to_target, rect)}; 158 MathUtil::ProjectClippedRect(current_to_target, rect)};
201 } 159 }
202 160
203 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, 161 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node,
(...skipping 279 matching lines...) Expand 10 before | Expand all | Expand 10 after
483 &combined_clip_rect_in_target_space)) { 441 &combined_clip_rect_in_target_space)) {
484 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); 442 layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
485 continue; 443 continue;
486 } 444 }
487 } else { 445 } else {
488 combined_clip_rect_in_target_space = 446 combined_clip_rect_in_target_space =
489 clip_node->combined_clip_in_target_space; 447 clip_node->combined_clip_in_target_space;
490 } 448 }
491 449
492 // The clip rect should be intersected with layer rect in target space. 450 // The clip rect should be intersected with layer rect in target space.
493 gfx::Transform content_to_target = transform_tree.ToTarget( 451 gfx::Transform content_to_target;
494 transform_node->id, layer->render_target_effect_tree_index()); 452 property_trees->GetToTarget(transform_node->id,
453 layer->render_target_effect_tree_index(),
454 &content_to_target);
495 content_to_target.Translate(layer->offset_to_transform_parent().x(), 455 content_to_target.Translate(layer->offset_to_transform_parent().x(),
496 layer->offset_to_transform_parent().y()); 456 layer->offset_to_transform_parent().y());
497 gfx::Rect layer_content_rect = gfx::Rect(layer_bounds); 457 gfx::Rect layer_content_rect = gfx::Rect(layer_bounds);
498 gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect( 458 gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect(
499 content_to_target, gfx::RectF(layer_content_rect)); 459 content_to_target, gfx::RectF(layer_content_rect));
500 // If the layer is fully contained within the clip, treat it as fully 460 // If the layer is fully contained within the clip, treat it as fully
501 // visible. 461 // visible.
502 if (!layer_content_bounds_in_target_space.IsEmpty() && 462 if (!layer_content_bounds_in_target_space.IsEmpty() &&
503 combined_clip_rect_in_target_space.Contains( 463 combined_clip_rect_in_target_space.Contains(
504 layer_content_bounds_in_target_space)) { 464 layer_content_bounds_in_target_space)) {
505 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); 465 layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
506 continue; 466 continue;
507 } 467 }
508 468
509 combined_clip_rect_in_target_space.Intersect( 469 combined_clip_rect_in_target_space.Intersect(
510 layer_content_bounds_in_target_space); 470 layer_content_bounds_in_target_space);
511 if (combined_clip_rect_in_target_space.IsEmpty()) { 471 if (combined_clip_rect_in_target_space.IsEmpty()) {
512 layer->set_visible_layer_rect(gfx::Rect()); 472 layer->set_visible_layer_rect(gfx::Rect());
513 continue; 473 continue;
514 } 474 }
515 475
516 gfx::Transform target_to_layer; 476 gfx::Transform target_to_layer;
517 if (transform_node->ancestors_are_invertible) { 477 if (transform_node->ancestors_are_invertible) {
518 target_to_layer = transform_tree.FromTarget( 478 property_trees->GetFromTarget(transform_node->id,
519 transform_node->id, layer->render_target_effect_tree_index()); 479 layer->render_target_effect_tree_index(),
480 &target_to_layer);
520 } else { 481 } else {
521 const EffectNode* target_effect_node = 482 const EffectNode* target_effect_node =
522 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree); 483 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
523 bool success = property_trees->ComputeTransformFromTarget( 484 bool success = property_trees->ComputeTransformFromTarget(
524 transform_node->id, target_effect_node->id, &target_to_layer); 485 transform_node->id, target_effect_node->id, &target_to_layer);
525 if (!success) { 486 if (!success) {
526 // An animated singular transform may become non-singular during the 487 // An animated singular transform may become non-singular during the
527 // animation, so we still need to compute a visible rect. In this 488 // animation, so we still need to compute a visible rect. In this
528 // situation, we treat the entire layer as visible. 489 // situation, we treat the entire layer as visible.
529 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); 490 layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
530 continue; 491 continue;
531 } 492 }
532 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer); 493 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
533 #if DCHECK_IS_ON()
534 VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
535 effect_tree, transform_tree);
536 #endif
537 } 494 }
538 gfx::Transform target_to_content; 495 gfx::Transform target_to_content;
539 target_to_content.Translate(-layer->offset_to_transform_parent().x(), 496 target_to_content.Translate(-layer->offset_to_transform_parent().x(),
540 -layer->offset_to_transform_parent().y()); 497 -layer->offset_to_transform_parent().y());
541 target_to_content.PreconcatTransform(target_to_layer); 498 target_to_content.PreconcatTransform(target_to_layer);
542 499
543 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( 500 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
544 target_to_content, combined_clip_rect_in_target_space)); 501 target_to_content, combined_clip_rect_in_target_space));
545 visible_rect.Intersect(gfx::Rect(layer_bounds)); 502 visible_rect.Intersect(gfx::Rect(layer_bounds));
546 layer->set_visible_layer_rect(visible_rect); 503 layer->set_visible_layer_rect(visible_rect);
547 } 504 }
548 } 505 }
549 506
550 static bool HasSingularTransform(int transform_tree_index, 507 static bool HasSingularTransform(int transform_tree_index,
551 const TransformTree& tree) { 508 const TransformTree& tree) {
552 const TransformNode* node = tree.Node(transform_tree_index); 509 const TransformNode* node = tree.Node(transform_tree_index);
553 return !node->is_invertible || !node->ancestors_are_invertible; 510 return !node->is_invertible || !node->ancestors_are_invertible;
554 } 511 }
555 512
556 template <typename LayerType> 513 template <typename LayerType>
557 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer, 514 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
558 const TransformTree& tree) { 515 const TransformTree& tree) {
559 if (!layer->use_parent_backface_visibility()) 516 if (!layer->use_parent_backface_visibility())
560 return layer->transform_tree_index(); 517 return layer->transform_tree_index();
561 const TransformNode* node = tree.Node(layer->transform_tree_index()); 518 const TransformNode* node = tree.Node(layer->transform_tree_index());
562 return layer->id() == node->owner_id ? tree.parent(node)->id : node->id; 519 return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
563 } 520 }
564 521
565 static bool IsTargetSpaceTransformBackFaceVisible(Layer* layer, 522 static bool IsTargetSpaceTransformBackFaceVisible(
566 int transform_tree_index, 523 Layer* layer,
567 const TransformTree& tree) { 524 int transform_tree_index,
525 const PropertyTrees* property_trees) {
568 // We do not skip back face invisible layers on main thread as target space 526 // We do not skip back face invisible layers on main thread as target space
569 // transform will not be available here. 527 // transform will not be available here.
570 return false; 528 return false;
571 } 529 }
572 530
573 static bool IsTargetSpaceTransformBackFaceVisible(LayerImpl* layer, 531 static bool IsTargetSpaceTransformBackFaceVisible(
574 int transform_tree_index, 532 LayerImpl* layer,
575 const TransformTree& tree) { 533 int transform_tree_index,
576 return tree 534 const PropertyTrees* property_trees) {
577 .ToTarget(transform_tree_index, layer->render_target_effect_tree_index()) 535 gfx::Transform to_target;
578 .IsBackFaceVisible(); 536 property_trees->GetToTarget(transform_tree_index,
537 layer->render_target_effect_tree_index(),
538 &to_target);
539 return to_target.IsBackFaceVisible();
579 } 540 }
580 541
581 template <typename LayerType> 542 template <typename LayerType>
582 static bool IsLayerBackFaceVisible(LayerType* layer, 543 static bool IsLayerBackFaceVisible(LayerType* layer,
583 int transform_tree_index, 544 int transform_tree_index,
584 const TransformTree& tree) { 545 const PropertyTrees* property_trees) {
585 const TransformNode* node = tree.Node(transform_tree_index); 546 const TransformNode* node =
547 property_trees->transform_tree.Node(transform_tree_index);
586 return layer->use_local_transform_for_backface_visibility() 548 return layer->use_local_transform_for_backface_visibility()
587 ? node->local.IsBackFaceVisible() 549 ? node->local.IsBackFaceVisible()
588 : IsTargetSpaceTransformBackFaceVisible( 550 : IsTargetSpaceTransformBackFaceVisible(
589 layer, transform_tree_index, tree); 551 layer, transform_tree_index, property_trees);
590 } 552 }
591 553
592 static inline bool TransformToScreenIsKnown(Layer* layer, 554 static inline bool TransformToScreenIsKnown(Layer* layer,
593 int transform_tree_index, 555 int transform_tree_index,
594 const TransformTree& tree) { 556 const TransformTree& tree) {
595 const TransformNode* node = tree.Node(transform_tree_index); 557 const TransformNode* node = tree.Node(transform_tree_index);
596 return !node->to_screen_is_potentially_animated; 558 return !node->to_screen_is_potentially_animated;
597 } 559 }
598 560
599 static inline bool TransformToScreenIsKnown(LayerImpl* layer, 561 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
600 int transform_tree_index, 562 int transform_tree_index,
601 const TransformTree& tree) { 563 const TransformTree& tree) {
602 return true; 564 return true;
603 } 565 }
604 566
605 template <typename LayerType> 567 template <typename LayerType>
606 static bool LayerNeedsUpdateInternal(LayerType* layer, 568 static bool LayerNeedsUpdateInternal(LayerType* layer,
607 bool layer_is_drawn, 569 bool layer_is_drawn,
608 const TransformTree& tree) { 570 const PropertyTrees* property_trees) {
609 // Layers can be skipped if any of these conditions are met. 571 // Layers can be skipped if any of these conditions are met.
610 // - is not drawn due to it or one of its ancestors being hidden (or having 572 // - is not drawn due to it or one of its ancestors being hidden (or having
611 // no copy requests). 573 // no copy requests).
612 // - does not draw content. 574 // - does not draw content.
613 // - is transparent. 575 // - is transparent.
614 // - has empty bounds 576 // - has empty bounds
615 // - the layer is not double-sided, but its back face is visible. 577 // - the layer is not double-sided, but its back face is visible.
616 // 578 //
617 // Some additional conditions need to be computed at a later point after the 579 // Some additional conditions need to be computed at a later point after the
618 // recursion is finished. 580 // recursion is finished.
619 // - the intersection of render_surface content and layer clip_rect is empty 581 // - the intersection of render_surface content and layer clip_rect is empty
620 // - the visible_layer_rect is empty 582 // - the visible_layer_rect is empty
621 // 583 //
622 // Note, if the layer should not have been drawn due to being fully 584 // Note, if the layer should not have been drawn due to being fully
623 // transparent, we would have skipped the entire subtree and never made it 585 // transparent, we would have skipped the entire subtree and never made it
624 // into this function, so it is safe to omit this check here. 586 // into this function, so it is safe to omit this check here.
625 if (!layer_is_drawn) 587 if (!layer_is_drawn)
626 return false; 588 return false;
627 589
628 if (!layer->DrawsContent() || layer->bounds().IsEmpty()) 590 if (!layer->DrawsContent() || layer->bounds().IsEmpty())
629 return false; 591 return false;
630 592
631 // The layer should not be drawn if (1) it is not double-sided and (2) the 593 // The layer should not be drawn if (1) it is not double-sided and (2) the
632 // back of the layer is known to be facing the screen. 594 // back of the layer is known to be facing the screen.
595 const TransformTree& tree = property_trees->transform_tree;
633 if (layer->should_check_backface_visibility()) { 596 if (layer->should_check_backface_visibility()) {
634 int backface_transform_id = 597 int backface_transform_id =
635 TransformTreeIndexForBackfaceVisibility(layer, tree); 598 TransformTreeIndexForBackfaceVisibility(layer, tree);
636 // A layer with singular transform is not drawn. So, we can assume that its 599 // A layer with singular transform is not drawn. So, we can assume that its
637 // backface is not visible. 600 // backface is not visible.
638 if (TransformToScreenIsKnown(layer, backface_transform_id, tree) && 601 if (TransformToScreenIsKnown(layer, backface_transform_id, tree) &&
639 !HasSingularTransform(backface_transform_id, tree) && 602 !HasSingularTransform(backface_transform_id, tree) &&
640 IsLayerBackFaceVisible(layer, backface_transform_id, tree)) 603 IsLayerBackFaceVisible(layer, backface_transform_id, property_trees))
641 return false; 604 return false;
642 } 605 }
643 606
644 return true; 607 return true;
645 } 608 }
646 609
647 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl, 610 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
648 const TransformTree& transform_tree, 611 const PropertyTrees* property_trees,
649 const EffectTree& effect_tree,
650 std::vector<LayerImpl*>* visible_layer_list) { 612 std::vector<LayerImpl*>* visible_layer_list) {
613 const TransformTree& transform_tree = property_trees->transform_tree;
614 const EffectTree& effect_tree = property_trees->effect_tree;
615
651 for (auto* layer_impl : *layer_tree_impl) { 616 for (auto* layer_impl : *layer_tree_impl) {
652 bool layer_is_drawn = 617 bool layer_is_drawn =
653 effect_tree.Node(layer_impl->effect_tree_index())->is_drawn; 618 effect_tree.Node(layer_impl->effect_tree_index())->is_drawn;
654 619
655 if (!IsRootLayer(layer_impl) && 620 if (!IsRootLayer(layer_impl) &&
656 LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree, 621 LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree,
657 effect_tree)) 622 effect_tree))
658 continue; 623 continue;
659 624
660 if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) 625 if (LayerNeedsUpdate(layer_impl, layer_is_drawn, property_trees))
661 visible_layer_list->push_back(layer_impl); 626 visible_layer_list->push_back(layer_impl);
662 } 627 }
663 } 628 }
664 629
665 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree, 630 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
666 bool non_root_surfaces_enabled, 631 bool non_root_surfaces_enabled,
667 LayerImpl* layer) { 632 LayerImpl* layer) {
668 if (!non_root_surfaces_enabled) { 633 if (!non_root_surfaces_enabled) {
669 layer->SetHasRenderSurface(IsRootLayer(layer)); 634 layer->SetHasRenderSurface(IsRootLayer(layer));
670 return; 635 return;
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
710 675
711 bool LayerShouldBeSkipped(Layer* layer, 676 bool LayerShouldBeSkipped(Layer* layer,
712 bool layer_is_drawn, 677 bool layer_is_drawn,
713 const TransformTree& transform_tree, 678 const TransformTree& transform_tree,
714 const EffectTree& effect_tree) { 679 const EffectTree& effect_tree) {
715 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree, 680 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree,
716 effect_tree); 681 effect_tree);
717 } 682 }
718 683
719 void FindLayersThatNeedUpdates(LayerTree* layer_tree, 684 void FindLayersThatNeedUpdates(LayerTree* layer_tree,
720 const TransformTree& transform_tree, 685 const PropertyTrees* property_trees,
721 const EffectTree& effect_tree,
722 LayerList* update_layer_list) { 686 LayerList* update_layer_list) {
687 const TransformTree& transform_tree = property_trees->transform_tree;
688 const EffectTree& effect_tree = property_trees->effect_tree;
723 for (auto* layer : *layer_tree) { 689 for (auto* layer : *layer_tree) {
724 bool layer_is_drawn = 690 bool layer_is_drawn =
725 effect_tree.Node(layer->effect_tree_index())->is_drawn; 691 effect_tree.Node(layer->effect_tree_index())->is_drawn;
726 692
727 if (!IsRootLayer(layer) && 693 if (!IsRootLayer(layer) &&
728 LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree, 694 LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree,
729 effect_tree)) 695 effect_tree))
730 continue; 696 continue;
731 697
732 if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) { 698 if (LayerNeedsUpdate(layer, layer_is_drawn, property_trees)) {
733 update_layer_list->push_back(layer); 699 update_layer_list->push_back(layer);
734 } 700 }
735 701
736 // Append mask layers to the update layer list. They don't have valid 702 // Append mask layers to the update layer list. They don't have valid
737 // visible rects, so need to get added after the above calculation. 703 // visible rects, so need to get added after the above calculation.
738 if (Layer* mask_layer = layer->mask_layer()) 704 if (Layer* mask_layer = layer->mask_layer())
739 update_layer_list->push_back(mask_layer); 705 update_layer_list->push_back(mask_layer);
740 } 706 }
741 } 707 }
742 708
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after
808 parent_clip_node->clip_in_target_space; 774 parent_clip_node->clip_in_target_space;
809 if (parent_target_transform_node && 775 if (parent_target_transform_node &&
810 parent_target_transform_node->id != clip_node->target_transform_id && 776 parent_target_transform_node->id != clip_node->target_transform_id &&
811 non_root_surfaces_enabled) { 777 non_root_surfaces_enabled) {
812 success &= property_trees->ComputeTransformFromTarget( 778 success &= property_trees->ComputeTransformFromTarget(
813 clip_node->target_transform_id, parent_clip_node->target_effect_id, 779 clip_node->target_transform_id, parent_clip_node->target_effect_id,
814 &parent_to_current); 780 &parent_to_current);
815 const EffectNode* target_effect_node = 781 const EffectNode* target_effect_node =
816 effect_tree.Node(clip_node->target_effect_id); 782 effect_tree.Node(clip_node->target_effect_id);
817 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current); 783 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
818 #if DCHECK_IS_ON()
819 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
820 clip_node->target_transform_id,
821 effect_tree, transform_tree);
822 #endif
823 const EffectNode* parent_target_effect_node = 784 const EffectNode* parent_target_effect_node =
824 effect_tree.Node(parent_clip_node->target_effect_id); 785 effect_tree.Node(parent_clip_node->target_effect_id);
825 ConcatInverseSurfaceContentsScale(parent_target_effect_node, 786 ConcatInverseSurfaceContentsScale(parent_target_effect_node,
826 &parent_to_current); 787 &parent_to_current);
827 #if DCHECK_IS_ON()
828 VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id,
829 parent_clip_node->target_transform_id,
830 effect_tree, transform_tree);
831 #endif
832 // If we can't compute a transform, it's because we had to use the inverse 788 // If we can't compute a transform, it's because we had to use the inverse
833 // of a singular transform. We won't draw in this case, so there's no need 789 // of a singular transform. We won't draw in this case, so there's no need
834 // to compute clips. 790 // to compute clips.
835 if (!success) 791 if (!success)
836 continue; 792 continue;
837 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( 793 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect(
838 parent_to_current, parent_clip_node->combined_clip_in_target_space); 794 parent_to_current, parent_clip_node->combined_clip_in_target_space);
839 parent_clip_in_target_space = MathUtil::ProjectClippedRect( 795 parent_clip_in_target_space = MathUtil::ProjectClippedRect(
840 parent_to_current, parent_clip_node->clip_in_target_space); 796 parent_to_current, parent_clip_node->clip_in_target_space);
841 } 797 }
842 // Only nodes affected by ancestor clips will have their clip adjusted due 798 // Only nodes affected by ancestor clips will have their clip adjusted due
843 // to intersecting with an ancestor clip. But, we still need to propagate 799 // to intersecting with an ancestor clip. But, we still need to propagate
844 // the combined clip to our children because if they are clipped, they may 800 // the combined clip to our children because if they are clipped, they may
845 // need to clip using our parent clip and if we don't propagate it here, 801 // need to clip using our parent clip and if we don't propagate it here,
846 // it will be lost. 802 // it will be lost.
847 if (clip_node->resets_clip && non_root_surfaces_enabled) { 803 if (clip_node->resets_clip && non_root_surfaces_enabled) {
848 if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) { 804 if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
849 clip_node->clip_in_target_space = MathUtil::MapClippedRect( 805 gfx::Transform to_target;
850 transform_tree.ToTarget(clip_node->transform_id, 806 property_trees->GetToTarget(clip_node->transform_id,
851 clip_node->target_effect_id), 807 clip_node->target_effect_id, &to_target);
852 clip_node->clip); 808 clip_node->clip_in_target_space =
809 MathUtil::MapClippedRect(to_target, clip_node->clip);
853 ResetIfHasNanCoordinate(&clip_node->clip_in_target_space); 810 ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
854 clip_node->combined_clip_in_target_space = 811 clip_node->combined_clip_in_target_space =
855 gfx::IntersectRects(clip_node->clip_in_target_space, 812 gfx::IntersectRects(clip_node->clip_in_target_space,
856 parent_combined_clip_in_target_space); 813 parent_combined_clip_in_target_space);
857 } else { 814 } else {
858 DCHECK(!clip_node->target_is_clipped); 815 DCHECK(!clip_node->target_is_clipped);
859 DCHECK(!clip_node->layers_are_clipped); 816 DCHECK(!clip_node->layers_are_clipped);
860 clip_node->combined_clip_in_target_space = 817 clip_node->combined_clip_in_target_space =
861 parent_combined_clip_in_target_space; 818 parent_combined_clip_in_target_space;
862 } 819 }
(...skipping 16 matching lines...) Expand all
879 // it to an empty rect. 836 // it to an empty rect.
880 clip_node->clip_in_target_space = gfx::RectF(); 837 clip_node->clip_in_target_space = gfx::RectF();
881 } 838 }
882 } else { 839 } else {
883 gfx::Transform source_to_target; 840 gfx::Transform source_to_target;
884 841
885 if (!non_root_surfaces_enabled) { 842 if (!non_root_surfaces_enabled) {
886 source_to_target = transform_tree.ToScreen(clip_node->transform_id); 843 source_to_target = transform_tree.ToScreen(clip_node->transform_id);
887 } else if (transform_tree.ContentTargetId(transform_node->id) == 844 } else if (transform_tree.ContentTargetId(transform_node->id) ==
888 clip_node->target_transform_id) { 845 clip_node->target_transform_id) {
889 source_to_target = transform_tree.ToTarget(clip_node->transform_id, 846 property_trees->GetToTarget(clip_node->transform_id,
890 clip_node->target_effect_id); 847 clip_node->target_effect_id,
848 &source_to_target);
891 } else { 849 } else {
892 success = property_trees->ComputeTransformToTarget( 850 success = property_trees->GetToTarget(
893 transform_node->id, clip_node->target_effect_id, &source_to_target); 851 transform_node->id, clip_node->target_effect_id, &source_to_target);
894 const EffectNode* target_effect_node =
895 effect_tree.Node(clip_node->target_effect_id);
896 PostConcatSurfaceContentsScale(target_effect_node, &source_to_target);
897 #if DCHECK_IS_ON()
898 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
899 clip_node->target_transform_id,
900 effect_tree, transform_tree);
901 #endif
902 // source_to_target computation should be successful as target is an 852 // source_to_target computation should be successful as target is an
903 // ancestor of the transform node. 853 // ancestor of the transform node.
904 DCHECK(success); 854 DCHECK(success);
905 } 855 }
906 856
907 gfx::RectF source_clip_in_target_space = 857 gfx::RectF source_clip_in_target_space =
908 MathUtil::MapClippedRect(source_to_target, clip_node->clip); 858 MathUtil::MapClippedRect(source_to_target, clip_node->clip);
909 859
910 // With surfaces disabled, the only case where we use only the local clip 860 // With surfaces disabled, the only case where we use only the local clip
911 // for layer clipping is the case where no non-viewport ancestor node 861 // for layer clipping is the case where no non-viewport ancestor node
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after
1026 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index() 976 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
1027 << " layer clip: " << layer->clip_rect().ToString() << " v.s. " 977 << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
1028 << gfx::ToEnclosingRect(accumulated_clip).ToString() 978 << gfx::ToEnclosingRect(accumulated_clip).ToString()
1029 << " and clip node clip: " 979 << " and clip node clip: "
1030 << gfx::ToEnclosingRect( 980 << gfx::ToEnclosingRect(
1031 clip_tree->Node(layer->clip_tree_index())->clip_in_target_space) 981 clip_tree->Node(layer->clip_tree_index())->clip_in_target_space)
1032 .ToString(); 982 .ToString();
1033 } 983 }
1034 } 984 }
1035 985
1036 static int FindTargetTransformTreeIndexFromEffectTree(
1037 const EffectTree& effect_tree,
1038 const int effect_tree_index) {
1039 const EffectNode* node = effect_tree.Node(effect_tree_index);
1040 if (node->has_render_surface)
1041 return node->transform_id;
1042 node = effect_tree.Node(node->target_id);
1043 return node->transform_id;
1044 }
1045
1046 static void VerifyDrawTransformsMatch(LayerImpl* layer,
1047 PropertyTrees* property_trees) {
1048 const int source_id = layer->transform_tree_index();
1049 int destination_id = FindTargetTransformTreeIndexFromEffectTree(
1050 property_trees->effect_tree, layer->effect_tree_index());
1051 const EffectNode* target_effect_node = ContentsTargetEffectNode(
1052 layer->effect_tree_index(), property_trees->effect_tree);
1053 gfx::Transform draw_transform;
1054 property_trees->ComputeTransformToTarget(source_id, target_effect_node->id,
1055 &draw_transform);
1056 PostConcatSurfaceContentsScale(target_effect_node, &draw_transform);
1057 #if DCHECK_IS_ON()
1058 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
1059 property_trees->effect_tree,
1060 property_trees->transform_tree);
1061 #endif
1062 if (layer->should_flatten_transform_from_property_tree())
1063 draw_transform.FlattenTo2d();
1064 draw_transform.Translate(layer->offset_to_transform_parent().x(),
1065 layer->offset_to_transform_parent().y());
1066 DCHECK(draw_transform.ApproximatelyEqual(DrawTransform(
1067 layer, property_trees->transform_tree, property_trees->effect_tree)))
1068 << " layer: " << layer->id() << " source transform id: " << source_id
1069 << " destination transform id: " << destination_id
1070 << " draw transform from transform tree: "
1071 << DrawTransform(layer, property_trees->transform_tree,
1072 property_trees->effect_tree)
1073 .ToString()
1074 << " v.s." << draw_transform.ToString();
1075 }
1076
1077 static void ComputeVisibleRectsInternal( 986 static void ComputeVisibleRectsInternal(
1078 LayerImpl* root_layer, 987 LayerImpl* root_layer,
1079 PropertyTrees* property_trees, 988 PropertyTrees* property_trees,
1080 bool can_render_to_separate_surface, 989 bool can_render_to_separate_surface,
1081 std::vector<LayerImpl*>* visible_layer_list) { 990 std::vector<LayerImpl*>* visible_layer_list) {
1082 if (property_trees->non_root_surfaces_enabled != 991 if (property_trees->non_root_surfaces_enabled !=
1083 can_render_to_separate_surface) { 992 can_render_to_separate_surface) {
1084 property_trees->non_root_surfaces_enabled = can_render_to_separate_surface; 993 property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
1085 property_trees->transform_tree.set_needs_update(true); 994 property_trees->transform_tree.set_needs_update(true);
1086 } 995 }
1087 if (property_trees->transform_tree.needs_update()) { 996 if (property_trees->transform_tree.needs_update()) {
1088 property_trees->clip_tree.set_needs_update(true); 997 property_trees->clip_tree.set_needs_update(true);
1089 property_trees->effect_tree.set_needs_update(true); 998 property_trees->effect_tree.set_needs_update(true);
1090 } 999 }
1091 UpdateRenderTarget(&property_trees->effect_tree, 1000 UpdateRenderTarget(&property_trees->effect_tree,
1092 property_trees->non_root_surfaces_enabled); 1001 property_trees->non_root_surfaces_enabled);
1093 ComputeTransforms(&property_trees->transform_tree); 1002 ComputeTransforms(&property_trees->transform_tree);
1094 // Computation of clips uses surface contents scale which is updated while 1003 // Computation of clips uses surface contents scale which is updated while
1095 // computing effects. So, ComputeEffects should be before ComputeClips. 1004 // computing effects. So, ComputeEffects should be before ComputeClips.
1096 ComputeEffects(&property_trees->effect_tree); 1005 ComputeEffects(&property_trees->effect_tree);
1097 ComputeClips(property_trees, can_render_to_separate_surface); 1006 ComputeClips(property_trees, can_render_to_separate_surface);
1098 1007
1099 FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), 1008 FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), property_trees,
1100 property_trees->transform_tree, 1009 visible_layer_list);
1101 property_trees->effect_tree, visible_layer_list);
1102 CalculateClipRects(*visible_layer_list, property_trees, 1010 CalculateClipRects(*visible_layer_list, property_trees,
1103 can_render_to_separate_surface); 1011 can_render_to_separate_surface);
1104 CalculateVisibleRects(*visible_layer_list, property_trees, 1012 CalculateVisibleRects(*visible_layer_list, property_trees,
1105 can_render_to_separate_surface); 1013 can_render_to_separate_surface);
1106 } 1014 }
1107 1015
1108 void UpdatePropertyTrees(PropertyTrees* property_trees, 1016 void UpdatePropertyTrees(PropertyTrees* property_trees,
1109 bool can_render_to_separate_surface) { 1017 bool can_render_to_separate_surface) {
1110 if (property_trees->non_root_surfaces_enabled != 1018 if (property_trees->non_root_surfaces_enabled !=
1111 can_render_to_separate_surface) { 1019 can_render_to_separate_surface) {
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
1148 1056
1149 void VerifyClipTreeCalculations(const LayerImplList& layer_list, 1057 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
1150 PropertyTrees* property_trees) { 1058 PropertyTrees* property_trees) {
1151 if (property_trees->non_root_surfaces_enabled) { 1059 if (property_trees->non_root_surfaces_enabled) {
1152 ComputeClipsWithEffectTree(property_trees); 1060 ComputeClipsWithEffectTree(property_trees);
1153 } 1061 }
1154 for (auto* layer : layer_list) 1062 for (auto* layer : layer_list)
1155 ComputeLayerClipRect(property_trees, layer); 1063 ComputeLayerClipRect(property_trees, layer);
1156 } 1064 }
1157 1065
1158 void VerifyTransformTreeCalculations(const LayerImplList& layer_list,
1159 PropertyTrees* property_trees) {
1160 for (auto* layer : layer_list)
1161 VerifyDrawTransformsMatch(layer, property_trees);
1162 }
1163
1164 void ComputeVisibleRects(LayerImpl* root_layer, 1066 void ComputeVisibleRects(LayerImpl* root_layer,
1165 PropertyTrees* property_trees, 1067 PropertyTrees* property_trees,
1166 bool can_render_to_separate_surface, 1068 bool can_render_to_separate_surface,
1167 LayerImplList* visible_layer_list) { 1069 LayerImplList* visible_layer_list) {
1168 for (auto* layer : *root_layer->layer_tree_impl()) { 1070 for (auto* layer : *root_layer->layer_tree_impl()) {
1169 UpdateRenderSurfaceForLayer(&property_trees->effect_tree, 1071 UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
1170 can_render_to_separate_surface, layer); 1072 can_render_to_separate_surface, layer);
1171 EffectNode* node = 1073 EffectNode* node =
1172 property_trees->effect_tree.Node(layer->effect_tree_index()); 1074 property_trees->effect_tree.Node(layer->effect_tree_index());
1173 if (node->owner_id == layer->id()) 1075 if (node->owner_id == layer->id())
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
1232 DCHECK(layer->visible_layer_rect() == visible_rect_dynamic) 1134 DCHECK(layer->visible_layer_rect() == visible_rect_dynamic)
1233 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index() 1135 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
1234 << " visible rect cached: " << layer->visible_layer_rect().ToString() 1136 << " visible rect cached: " << layer->visible_layer_rect().ToString()
1235 << " v.s. " 1137 << " v.s. "
1236 << " visible rect dynamic: " << visible_rect_dynamic.ToString(); 1138 << " visible rect dynamic: " << visible_rect_dynamic.ToString();
1237 } 1139 }
1238 } 1140 }
1239 1141
1240 bool LayerNeedsUpdate(Layer* layer, 1142 bool LayerNeedsUpdate(Layer* layer,
1241 bool layer_is_drawn, 1143 bool layer_is_drawn,
1242 const TransformTree& tree) { 1144 const PropertyTrees* property_trees) {
1243 return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree); 1145 return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
1244 } 1146 }
1245 1147
1246 bool LayerNeedsUpdate(LayerImpl* layer, 1148 bool LayerNeedsUpdate(LayerImpl* layer,
1247 bool layer_is_drawn, 1149 bool layer_is_drawn,
1248 const TransformTree& tree) { 1150 const PropertyTrees* property_trees) {
1249 return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree); 1151 return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
1250 } 1152 }
1251 1153
1252 gfx::Transform DrawTransform(const LayerImpl* layer, 1154 gfx::Transform DrawTransform(const LayerImpl* layer,
1253 const TransformTree& transform_tree, 1155 const TransformTree& transform_tree,
1254 const EffectTree& effect_tree) { 1156 const EffectTree& effect_tree) {
1255 // TransformTree::ToTarget computes transform between the layer's transform 1157 // TransformTree::ToTarget computes transform between the layer's transform
1256 // node and surface's transform node and scales it by the surface's content 1158 // node and surface's transform node and scales it by the surface's content
1257 // scale. 1159 // scale.
1258 gfx::Transform xform = 1160 gfx::Transform xform;
1259 transform_tree.property_trees()->non_root_surfaces_enabled 1161 if (transform_tree.property_trees()->non_root_surfaces_enabled)
1260 ? transform_tree.ToTarget(layer->transform_tree_index(), 1162 transform_tree.property_trees()->GetToTarget(
1261 layer->render_target_effect_tree_index()) 1163 layer->transform_tree_index(), layer->render_target_effect_tree_index(),
1262 : transform_tree.ToScreen(layer->transform_tree_index()); 1164 &xform);
1165 else
1166 xform = transform_tree.ToScreen(layer->transform_tree_index());
1263 if (layer->should_flatten_transform_from_property_tree()) 1167 if (layer->should_flatten_transform_from_property_tree())
1264 xform.FlattenTo2d(); 1168 xform.FlattenTo2d();
1265 xform.Translate(layer->offset_to_transform_parent().x(), 1169 xform.Translate(layer->offset_to_transform_parent().x(),
1266 layer->offset_to_transform_parent().y()); 1170 layer->offset_to_transform_parent().y());
1267 return xform; 1171 return xform;
1268 } 1172 }
1269 1173
1270 static void SetSurfaceDrawTransform(const PropertyTrees* property_trees, 1174 static void SetSurfaceDrawTransform(const PropertyTrees* property_trees,
1271 RenderSurfaceImpl* render_surface) { 1175 RenderSurfaceImpl* render_surface) {
1272 const TransformTree& transform_tree = property_trees->transform_tree; 1176 const TransformTree& transform_tree = property_trees->transform_tree;
1273 const EffectTree& effect_tree = property_trees->effect_tree; 1177 const EffectTree& effect_tree = property_trees->effect_tree;
1274 const TransformNode* transform_node = 1178 const TransformNode* transform_node =
1275 transform_tree.Node(render_surface->TransformTreeIndex()); 1179 transform_tree.Node(render_surface->TransformTreeIndex());
1276 const EffectNode* effect_node = 1180 const EffectNode* effect_node =
1277 effect_tree.Node(render_surface->EffectTreeIndex()); 1181 effect_tree.Node(render_surface->EffectTreeIndex());
1278 // The draw transform of root render surface is identity tranform. 1182 // The draw transform of root render surface is identity tranform.
1279 if (transform_node->id == 1) { 1183 if (transform_node->id == 1) {
1280 render_surface->SetDrawTransform(gfx::Transform()); 1184 render_surface->SetDrawTransform(gfx::Transform());
1281 return; 1185 return;
1282 } 1186 }
1283 1187
1284 gfx::Transform render_surface_transform; 1188 gfx::Transform render_surface_transform;
1285 const EffectNode* target_effect_node = 1189 const EffectNode* target_effect_node =
1286 effect_tree.Node(effect_node->target_id); 1190 effect_tree.Node(effect_node->target_id);
1287 property_trees->ComputeTransformToTarget( 1191 property_trees->GetToTarget(transform_node->id, target_effect_node->id,
1288 transform_node->id, target_effect_node->id, &render_surface_transform); 1192 &render_surface_transform);
1289 PostConcatSurfaceContentsScale(target_effect_node, &render_surface_transform);
1290 #if DCHECK_IS_ON()
1291 const TransformNode* target_transform_node =
1292 transform_tree.Node(transform_tree.TargetId(transform_node->id));
1293 VerifySurfaceContentsScalesMatch(effect_node->target_id,
1294 target_transform_node->id, effect_tree,
1295 transform_tree);
1296 #endif
1297 1193
1298 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform); 1194 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
1299 #if DCHECK_IS_ON()
1300 VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id,
1301 effect_tree, transform_tree);
1302 #endif
1303 render_surface->SetDrawTransform(render_surface_transform); 1195 render_surface->SetDrawTransform(render_surface_transform);
1304 } 1196 }
1305 1197
1306 static void SetSurfaceIsClipped(const ClipNode* clip_node, 1198 static void SetSurfaceIsClipped(const ClipNode* clip_node,
1307 RenderSurfaceImpl* render_surface) { 1199 RenderSurfaceImpl* render_surface) {
1308 DCHECK(render_surface->OwningLayerId() == clip_node->owner_id) 1200 DCHECK(render_surface->OwningLayerId() == clip_node->owner_id)
1309 << "we now create clip node for every render surface"; 1201 << "we now create clip node for every render surface";
1310 1202
1311 render_surface->SetIsClipped(clip_node->target_is_clipped); 1203 render_surface->SetIsClipped(clip_node->target_is_clipped);
1312 } 1204 }
(...skipping 17 matching lines...) Expand all
1330 return; 1222 return;
1331 } 1223 }
1332 1224
1333 // In this case, the clip child has reset the clip node for subtree and hence 1225 // In this case, the clip child has reset the clip node for subtree and hence
1334 // the parent clip node's clip rect is in clip parent's target space and not 1226 // the parent clip node's clip rect is in clip parent's target space and not
1335 // our target space. We need to transform it to our target space. 1227 // our target space. We need to transform it to our target space.
1336 gfx::Transform clip_parent_target_to_target; 1228 gfx::Transform clip_parent_target_to_target;
1337 const EffectNode* effect_node = 1229 const EffectNode* effect_node =
1338 effect_tree.Node(render_surface->EffectTreeIndex()); 1230 effect_tree.Node(render_surface->EffectTreeIndex());
1339 int target_effect_id = effect_node->target_id; 1231 int target_effect_id = effect_node->target_id;
1340 const bool success = property_trees->ComputeTransformToTarget( 1232 const bool success = property_trees->GetToTarget(
1341 parent_clip_node->target_transform_id, target_effect_id, 1233 parent_clip_node->target_transform_id, target_effect_id,
1342 &clip_parent_target_to_target); 1234 &clip_parent_target_to_target);
1343 1235
1344 if (!success) { 1236 if (!success) {
1345 render_surface->SetClipRect(gfx::Rect()); 1237 render_surface->SetClipRect(gfx::Rect());
1346 return; 1238 return;
1347 } 1239 }
1348 1240
1349 PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target);
1350 #if DCHECK_IS_ON()
1351 VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(),
1352 transform_tree.TargetId(transform_node->id),
1353 effect_tree, transform_tree);
1354 #endif
1355
1356 DCHECK_LT(parent_clip_node->target_transform_id, 1241 DCHECK_LT(parent_clip_node->target_transform_id,
1357 transform_tree.TargetId(transform_node->id)); 1242 transform_tree.TargetId(transform_node->id));
1358 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( 1243 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
1359 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); 1244 clip_parent_target_to_target, parent_clip_node->clip_in_target_space)));
1360 } 1245 }
1361 1246
1362 template <typename LayerType> 1247 template <typename LayerType>
1363 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, 1248 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
1364 const TransformTree& tree) { 1249 const TransformTree& tree) {
1365 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), 1250 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(),
(...skipping 210 matching lines...) Expand 10 before | Expand all | Expand 10 after
1576 void UpdateElasticOverscroll(PropertyTrees* property_trees, 1461 void UpdateElasticOverscroll(PropertyTrees* property_trees,
1577 const Layer* overscroll_elasticity_layer, 1462 const Layer* overscroll_elasticity_layer,
1578 const gfx::Vector2dF& elastic_overscroll) { 1463 const gfx::Vector2dF& elastic_overscroll) {
1579 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, 1464 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
1580 elastic_overscroll); 1465 elastic_overscroll);
1581 } 1466 }
1582 1467
1583 } // namespace draw_property_utils 1468 } // namespace draw_property_utils
1584 1469
1585 } // namespace cc 1470 } // namespace cc
OLDNEW
« no previous file with comments | « cc/trees/draw_property_utils.h ('k') | cc/trees/layer_tree_host_common.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698