cc : Use sublayer scale from effect tree (4)

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::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_surface_contents_scale)
-    return success;
-
-  transform->matrix().postScale(dest_node->surface_contents_scale.x(),
-                                dest_node->surface_contents_scale.y(), 1.f);
-  return success;
-}
-
 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;
   }
@@ skipping 231 matching lines @@
                                                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;
-    ComputeTransformWithDestinationSurfaceContentsScale(
-        node->id, target_id, &target_space_transform);
+    ComputeTransform(node->id, target_id, &target_space_transform);
+    if (target_id != 0) {
+      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,
@@ 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::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->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_ ==
              other.device_transform_scale_factor() &&
          nodes_affected_by_inner_viewport_bounds_delta_ ==
              other.nodes_affected_by_inner_viewport_bounds_delta() &&
@@ skipping 231 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(0, destination_id);
       source_id = 1;
     }
     gfx::Transform transform;
-    property_trees()
-        ->transform_tree.ComputeTransformWithDestinationSurfaceContentsScale(
-            source_id, destination_id, &transform);
+    property_trees()->transform_tree.ComputeTransform(source_id, destination_id,
+                                                      &transform);
+    if (destination_id != 0) {
+      transform.matrix().postScale(effect_node->surface_contents_scale.x(),
+                                   effect_node->surface_contents_scale.y(),
+                                   1.f);
+    }
     it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
   }
 }
 
 bool EffectTree::HasCopyRequests() const {
   return !copy_requests_.empty();
 }
 
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
@@ skipping 952 matching lines @@
 void PropertyTrees::ResetCachedData() {
   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++;
 }
 
+gfx::Transform PropertyTrees::ToScreenSpaceTransformWithoutSurfaceContentsScale(
+    int transform_id,
+    int effect_id) const {
+  DCHECK_GT(transform_id, 0);
+  if (transform_id == 1) {
+    return gfx::Transform();
+  }
+  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;
+}
+
 }  // namespace cc