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 139 matching lines @@
   if (source_id == dest_id)
     return true;
 
   if (source_id > dest_id) {
     return CombineTransformsBetween(source_id, dest_id, transform);
   }
 
   return CombineInversesBetween(source_id, dest_id, transform);
 }
 
-bool TransformTree::ComputeTransformWithDestinationSublayerScale(
+bool TransformTree::ComputeTransformWithDestinationSurfaceContentsScale(
     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);
 }
 
 void TransformTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     TransformNode* node = Node(id);
     node->transform_changed = false;
   }
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->source_node_id);
   property_trees()->UpdateCachedNumber();
   if (node->needs_local_transform_update || NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
   else
     UndoSnapping(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
-  UpdateSublayerScale(node);
+  UpdateSurfaceContentsScale(node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateNodeAndAncestorsHaveIntegerTranslations(node, parent_node);
   UpdateTransformChanged(node, parent_node, source_node);
   UpdateNodeAndAncestorsAreAnimatedOrInvertible(node, parent_node);
 }
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   while (desc_id != source_id) {
@@ skipping 28 matching lines @@
     return true;
   }
 
   // Flattening is defined in a way that requires it to be applied while
   // traversing downward in the tree. We first identify nodes that are on the
   // 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.
+  // zero surface contents scale, since stored target space transforms have
+  // surface contents 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.
+    // The stored target space transform has surface contents 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 105 matching lines @@
         parent_node->node_and_ancestors_are_flat && node->to_parent.IsFlat();
     SetToScreen(node->id, to_screen_space_transform);
   }
 
   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);
+void TransformTree::UpdateSurfaceContentsScale(TransformNode* node) {
+  // The surface contents scale depends on the screen space transform, so update
+  // it too.
+  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);
+    ComputeTransformWithDestinationSurfaceContentsScale(
+        node->id, target_id, &target_space_transform);
   }
 
   gfx::Transform from_target;
   if (!target_space_transform.GetInverse(&from_target))
     node->ancestors_are_invertible = false;
   SetToTarget(node->id, target_space_transform);
   SetFromTarget(node->id, from_target);
 }
 
 void TransformTree::UpdateAnimationProperties(TransformNode* node,
@@ skipping 195 matching lines @@
 int TransformTree::ContentTargetId(int node_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   return cached_data_[node_id].content_target_id;
 }
 
 void TransformTree::SetContentTargetId(int node_id, int content_target_id) {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].content_target_id = content_target_id;
 }
 
-gfx::Transform TransformTree::ToScreenSpaceTransformWithoutSublayerScale(
+gfx::Transform TransformTree::ToScreenSpaceTransformWithoutSurfaceContentsScale(
     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 143 matching lines @@
           node->hidden_by_backface_visibility =
               transform_node->local.IsBackFaceVisible();
         }
         return;
       }
     }
   }
   node->hidden_by_backface_visibility = false;
 }
 
-void EffectTree::UpdateSublayerScale(EffectNode* effect_node) {
+void EffectTree::UpdateSurfaceContentsScale(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);
-  UpdateSublayerScale(node);
+  UpdateSurfaceContentsScale(node);
 }
 
 void EffectTree::AddCopyRequest(int node_id,
                                 std::unique_ptr<CopyOutputRequest> request) {
   copy_requests_.insert(std::make_pair(node_id, std::move(request)));
 }
 
 void EffectTree::PushCopyRequestsTo(EffectTree* other_tree) {
   // If other_tree still has copy requests, this means there was a commit
   // without a draw. This only happens in some edge cases during lost context or
@@ skipping 45 matching lines @@
       source_id = destination_id;
     } else {
       // The root surface doesn't have the notion of sub-layer scale, but
       // instead has a similar notion of transforming from the space of the root
       // layer to the space of the screen.
       DCHECK_EQ(0, destination_id);
       source_id = 1;
     }
     gfx::Transform transform;
     property_trees()
-        ->transform_tree.ComputeTransformWithDestinationSublayerScale(
+        ->transform_tree.ComputeTransformWithDestinationSurfaceContentsScale(
             source_id, destination_id, &transform);
     it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
   }
 }
 
 bool EffectTree::HasCopyRequests() const {
   return !copy_requests_.empty();
 }
 
 void EffectTree::ClearCopyRequests() {
@@ skipping 944 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