Use surface contents scale from effect tree (3)

cc/trees/draw_property_utils.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 1025 matching lines @@
 #if DCHECK_IS_ON()
     VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
                                      property_trees->effect_tree,
                                      property_trees->transform_tree);
 #endif
   }
   if (layer->should_flatten_transform_from_property_tree())
     draw_transform.FlattenTo2d();
   draw_transform.Translate(layer->offset_to_transform_parent().x(),
                            layer->offset_to_transform_parent().y());
-  DCHECK(draw_transform.ApproximatelyEqual(
-      DrawTransform(layer, property_trees->transform_tree)))
+  DCHECK(draw_transform.ApproximatelyEqual(DrawTransform(
+      layer, property_trees->transform_tree, property_trees->effect_tree)))
       << " layer: " << layer->id() << " source transform id: " << source_id
       << " destination transform id: " << destination_id
       << " draw transform from transform tree: "
-      << DrawTransform(layer, property_trees->transform_tree).ToString()
+      << DrawTransform(layer, property_trees->transform_tree,
+                       property_trees->effect_tree)
+             .ToString()
       << " v.s." << draw_transform.ToString();
 }
 
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
     std::vector<LayerImpl*>* visible_layer_list) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
@@ skipping 119 matching lines @@
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
                       bool layer_is_drawn,
                       const TransformTree& tree) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
 }
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
-                             const TransformTree& tree) {
-  const TransformNode* node = tree.Node(layer->transform_tree_index());
+                             const TransformTree& transform_tree,
+                             const EffectTree& effect_tree) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
       !IsRootLayer(layer) && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
-    xform = tree.ToTarget(layer->transform_tree_index());
+    xform = transform_tree.ToTarget(layer->transform_tree_index());
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their surface contents scale.
-    xform.Scale(node->surface_contents_scale.x(),
-                node->surface_contents_scale.y());
+    const EffectNode* effect_node =
+        effect_tree.Node(layer->effect_tree_index());
+    xform.Scale(effect_node->surface_contents_scale.x(),
+                effect_node->surface_contents_scale.y());
+#if DCHECK_IS_ON()
+    VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
+                                     layer->transform_tree_index(), effect_tree,
+                                     transform_tree);
+#endif
   }
   return xform;
 }
 
 static void SetSurfaceDrawTransform(const TransformTree& transform_tree,
                                     const EffectTree& effect_tree,
                                     RenderSurfaceImpl* render_surface) {
   const TransformNode* transform_node =
       transform_tree.Node(render_surface->TransformTreeIndex());
   const EffectNode* effect_node =
@@ skipping 147 matching lines @@
     const gfx::Rect& layer_bounds_in_target_space,
     const gfx::Rect& clip_rect) {
   if (layer->is_clipped())
     return IntersectRects(layer_bounds_in_target_space, clip_rect);
 
   return layer_bounds_in_target_space;
 }
 
 static gfx::Transform ReplicaToSurfaceTransform(
     const RenderSurfaceImpl* render_surface,
-    const TransformTree& tree) {
+    const TransformTree& transform_tree,
+    const EffectTree& effect_tree) {
   gfx::Transform replica_to_surface;
   if (!render_surface->HasReplica())
     return replica_to_surface;
   const LayerImpl* replica_layer = render_surface->ReplicaLayer();
-  const TransformNode* surface_transform_node =
-      tree.Node(render_surface->TransformTreeIndex());
-  replica_to_surface.Scale(surface_transform_node->surface_contents_scale.x(),
-                           surface_transform_node->surface_contents_scale.y());
+  const EffectNode* surface_effect_node =
+      effect_tree.Node(render_surface->EffectTreeIndex());
+  if (render_surface->TransformTreeIndex() != 0) {
+    replica_to_surface.Scale(surface_effect_node->surface_contents_scale.x(),
+                             surface_effect_node->surface_contents_scale.y());
+#if DCHECK_IS_ON()
+    VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(),
+                                     render_surface->TransformTreeIndex(),
+                                     effect_tree, transform_tree);
+#endif
+  }
   replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(),
                                replica_layer->offset_to_transform_parent().y());
   gfx::Transform replica_transform_node_to_surface;
-  tree.ComputeTransform(replica_layer->transform_tree_index(),
-                        render_surface->TransformTreeIndex(),
-                        &replica_transform_node_to_surface);
+  transform_tree.ComputeTransform(replica_layer->transform_tree_index(),
+                                  render_surface->TransformTreeIndex(),
+                                  &replica_transform_node_to_surface);
   replica_to_surface.PreconcatTransform(replica_transform_node_to_surface);
-  if (surface_transform_node->surface_contents_scale.x() != 0 &&
-      surface_transform_node->surface_contents_scale.y() != 0) {
+  if (surface_effect_node->surface_contents_scale.x() != 0 &&
+      surface_effect_node->surface_contents_scale.y() != 0) {
     replica_to_surface.Scale(
-        1.0 / surface_transform_node->surface_contents_scale.x(),
-        1.0 / surface_transform_node->surface_contents_scale.y());
+        1.0 / surface_effect_node->surface_contents_scale.x(),
+        1.0 / surface_effect_node->surface_contents_scale.y());
   }
   return replica_to_surface;
 }
 
 void ComputeLayerDrawProperties(LayerImpl* layer,
                                 const PropertyTrees* property_trees) {
   const TransformNode* transform_node =
       property_trees->transform_tree.Node(layer->transform_tree_index());
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
   layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(layer, property_trees->transform_tree);
   if (property_trees->non_root_surfaces_enabled) {
-    layer->draw_properties().target_space_transform =
-        DrawTransform(layer, property_trees->transform_tree);
+    layer->draw_properties().target_space_transform = DrawTransform(
+        layer, property_trees->transform_tree, property_trees->effect_tree);
   } else {
     layer->draw_properties().target_space_transform =
         layer->draw_properties().screen_space_transform;
   }
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->to_screen_is_potentially_animated;
 
   layer->draw_properties().opacity =
       LayerDrawOpacity(layer, property_trees->effect_tree);
   if (property_trees->non_root_surfaces_enabled) {
@@ skipping 30 matching lines @@
   SetSurfaceDrawOpacity(property_trees->effect_tree, render_surface);
   SetSurfaceDrawTransform(property_trees->transform_tree,
                           property_trees->effect_tree, render_surface);
   render_surface->SetScreenSpaceTransform(
       property_trees->transform_tree
           .ToScreenSpaceTransformWithoutSurfaceContentsScale(
               render_surface->TransformTreeIndex()));
 
   if (render_surface->HasReplica()) {
     gfx::Transform replica_to_surface = ReplicaToSurfaceTransform(
-        render_surface, property_trees->transform_tree);
+        render_surface, property_trees->transform_tree,
+        property_trees->effect_tree);
     render_surface->SetReplicaDrawTransform(render_surface->draw_transform() *
                                             replica_to_surface);
     render_surface->SetReplicaScreenSpaceTransform(
         render_surface->screen_space_transform() * replica_to_surface);
   } else {
     render_surface->SetReplicaDrawTransform(gfx::Transform());
     render_surface->SetReplicaScreenSpaceTransform(gfx::Transform());
   }
 
   SetSurfaceClipRect(property_trees->clip_tree.parent(clip_node),
@@ skipping 96 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc