cc: Compute sublayer scale from effect 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"
@@ skipping 496 matching lines @@
       replica_mask_layer_id(-1) {}
 
 EffectNodeData::EffectNodeData(const EffectNodeData& other) = default;
 
 bool EffectNodeData::operator==(const EffectNodeData& other) const {
   return opacity == other.opacity &&
          screen_space_opacity == other.screen_space_opacity &&
          has_render_surface == other.has_render_surface &&
          has_copy_request == other.has_copy_request &&
          background_filters == other.background_filters &&
+         sublayer_scale == other.sublayer_scale &&
          hidden_by_backface_visibility == other.hidden_by_backface_visibility &&
          double_sided == other.double_sided && is_drawn == other.is_drawn &&
          subtree_hidden == other.subtree_hidden &&
          has_potential_opacity_animation ==
              other.has_potential_opacity_animation &&
          is_currently_animating_opacity ==
              other.is_currently_animating_opacity &&
          effect_changed == other.effect_changed &&
          num_copy_requests_in_subtree == other.num_copy_requests_in_subtree &&
          transform_id == other.transform_id && clip_id == other.clip_id &&
@@ skipping 16 matching lines @@
   data->set_has_potential_opacity_animation(has_potential_opacity_animation);
   data->set_is_currently_animating_opacity(is_currently_animating_opacity);
   data->set_effect_changed(effect_changed);
   data->set_num_copy_requests_in_subtree(num_copy_requests_in_subtree);
   data->set_transform_id(transform_id);
   data->set_clip_id(clip_id);
   data->set_target_id(target_id);
   data->set_mask_layer_id(mask_layer_id);
   data->set_replica_layer_id(replica_layer_id);
   data->set_replica_mask_layer_id(replica_mask_layer_id);
+  Vector2dFToProto(sublayer_scale, data->mutable_sublayer_scale());
 }
 
 void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_effect_node_data());
   const proto::EffectNodeData& data = proto.effect_node_data();
 
   opacity = data.opacity();
   screen_space_opacity = data.screen_space_opacity();
   has_render_surface = data.has_render_surface();
   has_copy_request = data.has_copy_request();
   hidden_by_backface_visibility = data.hidden_by_backface_visibility();
   double_sided = data.double_sided();
   is_drawn = data.is_drawn();
   subtree_hidden = data.subtree_hidden();
   has_potential_opacity_animation = data.has_potential_opacity_animation();
   is_currently_animating_opacity = data.is_currently_animating_opacity();
   effect_changed = data.effect_changed();
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
   target_id = data.target_id();
   mask_layer_id = data.mask_layer_id();
   replica_layer_id = data.replica_layer_id();
   replica_mask_layer_id = data.replica_mask_layer_id();
+  sublayer_scale = ProtoToVector2dF(data.sublayer_scale());
 }
 
 void EffectNodeData::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetDouble("opacity", opacity);
   value->SetBoolean("has_render_surface", has_render_surface);
   value->SetBoolean("has_copy_request", has_copy_request);
   value->SetBoolean("double_sided", double_sided);
   value->SetBoolean("is_drawn", is_drawn);
   value->SetBoolean("has_potential_opacity_animation",
                     has_potential_opacity_animation);
@@ skipping 824 matching lines @@
           node->data.hidden_by_backface_visibility =
               transform_node->data.local.IsBackFaceVisible();
         }
         return;
       }
     }
   }
   node->data.hidden_by_backface_visibility = false;
 }
 
+void EffectTree::UpdateSublayerScale(EffectNode* effect_node) {
+  if (!effect_node->data.has_render_surface ||
+      effect_node->data.transform_id == 0) {
+    effect_node->data.sublayer_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->data.transform_id);
+  if (transform_node->data.in_subtree_of_page_scale_layer)
+    layer_scale_factor *= transform_tree.page_scale_factor();
+  effect_node->data.sublayer_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);
 }
 
 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 1011 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