cc: Clean up transform tree

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"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/proto/synced_property_conversions.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
+
 namespace cc {
 
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
   nodes_.push_back(T());
   back()->id = kRootNodeId;
   back()->parent_id = kInvalidNodeId;
 }
 
@@ skipping 136 matching lines @@
   DCHECK(tree == *this);
 #endif
 }
 
 void TransformTree::set_needs_update(bool needs_update) {
   if (needs_update && !needs_update_)
     property_trees()->UpdateCachedNumber();
   needs_update_ = needs_update;
 }
 
-bool TransformTree::ComputeTransform(int source_id,
-                                     int dest_id,
-                                     gfx::Transform* transform) const {
+bool TransformTree::ComputeTransformForTesting(
+    int source_id,
+    int dest_id,
+    gfx::Transform* transform) const {
   transform->MakeIdentity();
 
   if (source_id == dest_id)
     return true;
 
   if (source_id > dest_id) {
     CombineTransformsBetween(source_id, dest_id, transform);
     return true;
   }
 
@@ skipping 75 matching lines @@
   TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->source_node_id);
   // TODO(flackr): Only dirty when scroll offset changes.
   if (node->sticky_position_constraint_id >= 0 ||
       node->needs_local_transform_update || NeedsSourceToParentUpdate(node)) {
     UpdateLocalTransform(node);
   } else {
     UndoSnapping(node);
   }
   UpdateScreenSpaceTransform(node, parent_node, target_node);
-  UpdateSurfaceContentsScale(node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(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) {
     if (desc_id == kInvalidNodeId)
@@ skipping 33 matching lines @@
   // 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 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_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))
     source_to_destination.push_back(current->id);
 
   gfx::Transform combined_transform;
-  if (current->id > dest_id) {
-    // The stored target space transform has surface contents scale baked in,
-    // but we need the unscaled transform.
-    combined_transform.matrix().postScale(
-        1.0f / dest->surface_contents_scale.x(),
-        1.0f / dest->surface_contents_scale.y(), 1.0f);
-  } else if (current->id < dest_id) {
+  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
     //    |
     //    T
@@ skipping 215 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::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->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_surface_contents_scale) {
-    target_space_transform.MakeIdentity();
-    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;
-    ComputeTransform(node->id, target_id, &target_space_transform);
-    target_space_transform.matrix().postScale(
-        target_node->surface_contents_scale.x(),
-        target_node->surface_contents_scale.y(), 1.f);
-  }
-
-  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,
                                               TransformNode* parent_node) {
   bool ancestor_is_animating = false;
   if (parent_node)
     ancestor_is_animating = parent_node->to_screen_is_potentially_animated;
   node->to_screen_is_potentially_animated =
       node->has_potential_animation || ancestor_is_animating;
 }
 
 void TransformTree::UndoSnapping(TransformNode* node) {
@@ skipping 85 matching lines @@
   if (node->post_local == post_local)
     return;
   node->post_local = post_local;
   node->needs_local_transform_update = true;
   set_needs_update(true);
 }
 
 void TransformTree::SetScreenSpaceScaleOnRootNode(
     gfx::Vector2dF screen_space_scale_components) {
   TransformNode* node = Node(kRootNodeId);
-  if (node->surface_contents_scale == screen_space_scale_components)
+  gfx::Transform to_screen;
+  to_screen.Scale(screen_space_scale_components.x(),
+                  screen_space_scale_components.y());
+  if (ToScreen(node->id) == to_screen)
     return;
-  node->needs_surface_contents_scale = true;
-  node->surface_contents_scale = screen_space_scale_components;
-  gfx::Transform to_screen;
-  to_screen.Scale(node->surface_contents_scale.x(),
-                  node->surface_contents_scale.y());
   SetToScreen(node->id, to_screen);
   gfx::Transform from_screen;
   if (!ToScreen(node->id).GetInverse(&from_screen))
     node->ancestors_are_invertible = false;
   SetFromScreen(node->id, from_screen);
   set_needs_update(true);
 }
 
 void TransformTree::SetRootTransformsAndScales(
     float device_scale_factor,
@@ skipping 49 matching lines @@
 }
 
 bool TransformTree::HasNodesAffectedByInnerViewportBoundsDelta() const {
   return !nodes_affected_by_inner_viewport_bounds_delta_.empty();
 }
 
 bool TransformTree::HasNodesAffectedByOuterViewportBoundsDelta() const {
   return !nodes_affected_by_outer_viewport_bounds_delta_.empty();
 }
 
-gfx::Transform TransformTree::FromTarget(int node_id, int effect_id) const {
-  gfx::Transform from_target;
-  property_trees()->GetFromTarget(node_id, effect_id, &from_target);
-  return from_target;
-}
-
-void TransformTree::SetFromTarget(int node_id,
-                                  const gfx::Transform& transform) {
-  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
-  cached_data_[node_id].from_target = transform;
-}
-
-gfx::Transform TransformTree::ToTarget(int node_id, int effect_id) const {
-  gfx::Transform to_target;
-  property_trees()->GetToTarget(node_id, effect_id, &to_target);
-  return to_target;
-}
-
-void TransformTree::SetToTarget(int node_id, const gfx::Transform& transform) {
-  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
-  cached_data_[node_id].to_target = transform;
-}
-
 const gfx::Transform& TransformTree::FromScreen(int node_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   return cached_data_[node_id].from_screen;
 }
 
 void TransformTree::SetFromScreen(int node_id,
                                   const gfx::Transform& transform) {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].from_screen = transform;
 }
@@ skipping 188 matching lines @@
     TransformNode* transform_node = transform_tree.Node(node->transform_id);
     if (transform_node->is_invertible &&
         transform_node->ancestors_are_invertible) {
       if (transform_node->sorting_context_id) {
         const TransformNode* parent_transform_node =
             transform_tree.parent(transform_node);
         if (parent_transform_node &&
             parent_transform_node->sorting_context_id ==
                 transform_node->sorting_context_id) {
           gfx::Transform surface_draw_transform;
-          property_trees()->ComputeTransformToTarget(
-              transform_node->id, node->target_id, &surface_draw_transform);
+          property_trees()->GetToTarget(transform_node->id, node->target_id,
+                                        &surface_draw_transform);
           node->hidden_by_backface_visibility =
               surface_draw_transform.IsBackFaceVisible();
         } else {
           node->hidden_by_backface_visibility =
               transform_node->local.IsBackFaceVisible();
         }
         return;
       }
     }
   }
@@ skipping 112 matching lines @@
       // For non-root surfaces, transform only by sub-layer scale.
       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(kRootNodeId, destination_id);
       source_id = TransformTree::kContentsRootNodeId;
     }
     gfx::Transform transform;
-    property_trees()->transform_tree.ComputeTransform(source_id, destination_id,
-                                                      &transform);
-    transform.matrix().postScale(effect_node->surface_contents_scale.x(),
-                                 effect_node->surface_contents_scale.y(), 1.f);
+    property_trees()->GetToTarget(source_id, node_id, &transform);
     it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
   }
 }
 
 bool EffectTree::HasCopyRequests() const {
   return !copy_requests_.empty();
 }
 
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
@@ skipping 1146 matching lines @@
   gfx::Transform screen_space_transform = transform_tree.ToScreen(transform_id);
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
-bool PropertyTrees::ComputeTransformToTarget(int transform_id,
-                                             int effect_id,
-                                             gfx::Transform* transform) const {
-  transform->MakeIdentity();
-  if (transform_id == TransformTree::kInvalidNodeId)
-    return true;
-
-  const EffectNode* effect_node = effect_tree.Node(effect_id);
-
-  bool success = true;
-  success = GetToTarget(transform_id, effect_id, transform);
-  if (effect_node->surface_contents_scale.x() != 0.f &&
-      effect_node->surface_contents_scale.y() != 0.f)
-    transform->matrix().postScale(
-        1.0f / effect_node->surface_contents_scale.x(),
-        1.0f / effect_node->surface_contents_scale.y(), 1.0f);
-  return success;
-}
-
 bool PropertyTrees::ComputeTransformFromTarget(
     int transform_id,
     int effect_id,
     gfx::Transform* transform) const {
   transform->MakeIdentity();
   if (transform_id == TransformTree::kInvalidNodeId)
     return true;
 
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   bool success = GetFromTarget(transform_id, effect_id, transform);
   transform->Scale(effect_node->surface_contents_scale.x(),
                    effect_node->surface_contents_scale.y());
   return success;
 }
 
 }  // namespace cc