cc: Use sublayer scale from effect tree (2)

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 146 matching lines @@
   return CombineInversesBetween(source_id, dest_id, transform);
 }
 
 bool TransformTree::ComputeTransformWithDestinationSublayerScale(
     int source_id,
     int dest_id,
     gfx::Transform* transform) const {
   bool success = ComputeTransform(source_id, dest_id, transform);
 
   const TransformNode* dest_node = Node(dest_id);
-  if (!dest_node->needs_sublayer_scale)
+  if (!dest_node->needs_surface_contents_scale)
     return success;
 
-  transform->matrix().postScale(dest_node->sublayer_scale.x(),
-                                dest_node->sublayer_scale.y(), 1.f);
+  transform->matrix().postScale(dest_node->surface_contents_scale.x(),
+                                dest_node->surface_contents_scale.y(), 1.f);
   return success;
 }
 
-bool TransformTree::ComputeTransformWithSourceSublayerScale(
-    int source_id,
-    int dest_id,
-    gfx::Transform* transform) const {
-  bool success = ComputeTransform(source_id, dest_id, transform);
-
-  const TransformNode* source_node = Node(source_id);
-  if (!source_node->needs_sublayer_scale)
-    return success;
-
-  if (source_node->sublayer_scale.x() == 0 ||
-      source_node->sublayer_scale.y() == 0)
-    return false;
-
-  transform->Scale(1.f / source_node->sublayer_scale.x(),
-                   1.f / source_node->sublayer_scale.y());
-  return success;
-}
-
 bool TransformTree::Are2DAxisAligned(int source_id, int dest_id) const {
   gfx::Transform transform;
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
 bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
   return (source_to_parent_updates_allowed() &&
           node->parent_id != node->source_node_id);
 }
@@ skipping 63 matching lines @@
   // path from the source to the destination (this is traversing upward), and
   // then we visit these nodes in reverse order, flattening as needed. We
   // early-out if we get to a node whose target node is the destination, since
   // we can then re-use the target space transform stored at that node. However,
   // we cannot re-use a stored target space transform if the destination has a
   // zero sublayer scale, since stored target space transforms have sublayer
   // scale baked in, but we need to compute an unscaled transform.
   std::vector<int> source_to_destination;
   source_to_destination.push_back(current->id);
   current = parent(current);
-  bool destination_has_non_zero_sublayer_scale =
-      dest->sublayer_scale.x() != 0.f && dest->sublayer_scale.y() != 0.f;
-  DCHECK(destination_has_non_zero_sublayer_scale ||
+  bool destination_has_non_zero_surface_contents_scale =
+      dest->surface_contents_scale.x() != 0.f &&
+      dest->surface_contents_scale.y() != 0.f;
+  DCHECK(destination_has_non_zero_surface_contents_scale ||
          !dest->ancestors_are_invertible);
   for (; current && current->id > dest_id; current = parent(current)) {
-    if (destination_has_non_zero_sublayer_scale &&
+    if (destination_has_non_zero_surface_contents_scale &&
         TargetId(current->id) == dest_id &&
         ContentTargetId(current->id) == dest_id)
       break;
     source_to_destination.push_back(current->id);
   }
 
   gfx::Transform combined_transform;
   if (current->id > dest_id) {
     combined_transform = ToTarget(current->id);
     // The stored target space transform has sublayer scale baked in, but we
     // need the unscaled transform.
     combined_transform.matrix().postScale(
-        1.0f / dest->sublayer_scale.x(), 1.0f / dest->sublayer_scale.y(), 1.0f);
+        1.0f / dest->surface_contents_scale.x(),
+        1.0f / dest->surface_contents_scale.y(), 1.0f);
   } else if (current->id < dest_id) {
     // We have reached the lowest common ancestor of the source and destination
     // nodes. This case can occur when we are transforming between a node
     // corresponding to a fixed-position layer (or its descendant) and the node
     // corresponding to the layer's render target. For example, consider the
     // layer tree R->T->S->F where F is fixed-position, S owns a render surface,
     // and T has a significant transform. This will yield the following
     // transform tree:
     //    R
     //    |
@@ skipping 107 matching lines @@
   }
 
   gfx::Transform from_screen;
   if (!ToScreen(node->id).GetInverse(&from_screen))
     node->ancestors_are_invertible = false;
   SetFromScreen(node->id, from_screen);
 }
 
 void TransformTree::UpdateSublayerScale(TransformNode* node) {
   // The sublayer scale depends on the screen space transform, so update it too.
-  if (!node->needs_sublayer_scale) {
-    node->sublayer_scale = gfx::Vector2dF(1.0f, 1.0f);
+  if (!node->needs_surface_contents_scale) {
+    node->surface_contents_scale = gfx::Vector2dF(1.0f, 1.0f);
     return;
   }
 
   float layer_scale_factor =
       device_scale_factor_ * device_transform_scale_factor_;
   if (node->in_subtree_of_page_scale_layer)
     layer_scale_factor *= page_scale_factor_;
-  node->sublayer_scale = MathUtil::ComputeTransform2dScaleComponents(
+  node->surface_contents_scale = MathUtil::ComputeTransform2dScaleComponents(
       ToScreen(node->id), layer_scale_factor);
 }
 
 void TransformTree::UpdateTargetSpaceTransform(TransformNode* node,
                                                TransformNode* target_node) {
   gfx::Transform target_space_transform;
-  if (node->needs_sublayer_scale) {
+  if (node->needs_surface_contents_scale) {
     target_space_transform.MakeIdentity();
-    target_space_transform.Scale(node->sublayer_scale.x(),
-                                 node->sublayer_scale.y());
+    target_space_transform.Scale(node->surface_contents_scale.x(),
+                                 node->surface_contents_scale.y());
   } else {
     // In order to include the root transform for the root surface, we walk up
     // to the root of the transform tree in ComputeTransform.
     int target_id = target_node->id;
     ComputeTransformWithDestinationSublayerScale(node->id, target_id,
                                                  &target_space_transform);
   }
 
   gfx::Transform from_target;
   if (!target_space_transform.GetInverse(&from_target))
@@ skipping 209 matching lines @@
 }
 
 gfx::Transform TransformTree::ToScreenSpaceTransformWithoutSublayerScale(
     int id) const {
   DCHECK_GT(id, 0);
   if (id == 1) {
     return gfx::Transform();
   }
   const TransformNode* node = Node(id);
   gfx::Transform screen_space_transform = ToScreen(id);
-  if (node->sublayer_scale.x() != 0.0 && node->sublayer_scale.y() != 0.0)
-    screen_space_transform.Scale(1.0 / node->sublayer_scale.x(),
-                                 1.0 / node->sublayer_scale.y());
+  if (node->surface_contents_scale.x() != 0.0 &&
+      node->surface_contents_scale.y() != 0.0)
+    screen_space_transform.Scale(1.0 / node->surface_contents_scale.x(),
+                                 1.0 / node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 bool TransformTree::operator==(const TransformTree& other) const {
   return PropertyTree::operator==(other) &&
          source_to_parent_updates_allowed_ ==
              other.source_to_parent_updates_allowed() &&
          page_scale_factor_ == other.page_scale_factor() &&
          device_scale_factor_ == other.device_scale_factor() &&
          device_transform_scale_factor_ ==
@@ skipping 145 matching lines @@
         }
         return;
       }
     }
   }
   node->hidden_by_backface_visibility = false;
 }
 
 void EffectTree::UpdateSublayerScale(EffectNode* effect_node) {
   if (!effect_node->has_render_surface || effect_node->transform_id == 0) {
-    effect_node->sublayer_scale = gfx::Vector2dF(1.0f, 1.0f);
+    effect_node->surface_contents_scale = gfx::Vector2dF(1.0f, 1.0f);
     return;
   }
 
   TransformTree& transform_tree = property_trees()->transform_tree;
   float layer_scale_factor = transform_tree.device_scale_factor() *
                              transform_tree.device_transform_scale_factor();
   TransformNode* transform_node =
       transform_tree.Node(effect_node->transform_id);
   if (transform_node->in_subtree_of_page_scale_layer)
     layer_scale_factor *= transform_tree.page_scale_factor();
-  effect_node->sublayer_scale = MathUtil::ComputeTransform2dScaleComponents(
-      transform_tree.ToScreen(transform_node->id), layer_scale_factor);
+  effect_node->surface_contents_scale =
+      MathUtil::ComputeTransform2dScaleComponents(
+          transform_tree.ToScreen(transform_node->id), layer_scale_factor);
 }
 
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
   UpdateEffectChanged(node, parent_node);
   UpdateBackfaceVisibility(node, parent_node);
@@ skipping 1021 matching lines @@
   cached_data_.property_tree_update_number = 0;
   cached_data_.animation_scales = std::vector<AnimationScaleData>(
       transform_tree.nodes().size(), AnimationScaleData());
 }
 
 void PropertyTrees::UpdateCachedNumber() {
   cached_data_.property_tree_update_number++;
 }
 
 }  // namespace cc