cc: Use sublayer scale from effect tree (1)

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 385 matching lines @@
   from_target = ProtoToTransform(proto.from_target());
   to_target = ProtoToTransform(proto.to_target());
   from_screen = ProtoToTransform(proto.from_screen());
   to_screen = ProtoToTransform(proto.to_screen());
   target_id = proto.target_id();
   content_target_id = proto.content_target_id();
 }
 
 ClipNodeData::ClipNodeData()
     : transform_id(-1),
-      target_id(-1),
+      target_transform_id(-1),
+      target_effect_id(-1),
       applies_local_clip(true),
       layer_clipping_uses_only_local_clip(false),
       target_is_clipped(false),
       layers_are_clipped(false),
       layers_are_clipped_when_surfaces_disabled(false),
       resets_clip(false) {}
 
 ClipNodeData::ClipNodeData(const ClipNodeData& other) = default;
 
 bool ClipNodeData::operator==(const ClipNodeData& other) const {
   return clip == other.clip &&
          combined_clip_in_target_space == other.combined_clip_in_target_space &&
          clip_in_target_space == other.clip_in_target_space &&
-         transform_id == other.transform_id && target_id == other.target_id &&
+         transform_id == other.transform_id &&
+         target_transform_id == other.target_transform_id &&
+         target_effect_id == other.target_effect_id &&
          applies_local_clip == other.applies_local_clip &&
          layer_clipping_uses_only_local_clip ==
              other.layer_clipping_uses_only_local_clip &&
          target_is_clipped == other.target_is_clipped &&
          layers_are_clipped == other.layers_are_clipped &&
          layers_are_clipped_when_surfaces_disabled ==
              other.layers_are_clipped_when_surfaces_disabled &&
          resets_clip == other.resets_clip;
 }
 
 void ClipNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_clip_node_data());
   proto::ClipNodeData* data = proto->mutable_clip_node_data();
 
   RectFToProto(clip, data->mutable_clip());
   RectFToProto(combined_clip_in_target_space,
                data->mutable_combined_clip_in_target_space());
   RectFToProto(clip_in_target_space, data->mutable_clip_in_target_space());
 
   data->set_transform_id(transform_id);
-  data->set_target_id(target_id);
+  data->set_target_transform_id(target_transform_id);
+  data->set_target_effect_id(target_effect_id);
   data->set_applies_local_clip(applies_local_clip);
   data->set_layer_clipping_uses_only_local_clip(
       layer_clipping_uses_only_local_clip);
   data->set_target_is_clipped(target_is_clipped);
   data->set_layers_are_clipped(layers_are_clipped);
   data->set_layers_are_clipped_when_surfaces_disabled(
       layers_are_clipped_when_surfaces_disabled);
   data->set_resets_clip(resets_clip);
 }
 
 void ClipNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_clip_node_data());
   const proto::ClipNodeData& data = proto.clip_node_data();
 
   clip = ProtoToRectF(data.clip());
   combined_clip_in_target_space =
       ProtoToRectF(data.combined_clip_in_target_space());
   clip_in_target_space = ProtoToRectF(data.clip_in_target_space());
 
   transform_id = data.transform_id();
-  target_id = data.target_id();
+  target_transform_id = data.target_transform_id();
+  target_effect_id = data.target_effect_id();
   applies_local_clip = data.applies_local_clip();
   layer_clipping_uses_only_local_clip =
       data.layer_clipping_uses_only_local_clip();
   target_is_clipped = data.target_is_clipped();
   layers_are_clipped = data.layers_are_clipped();
   layers_are_clipped_when_surfaces_disabled =
       data.layers_are_clipped_when_surfaces_disabled();
   resets_clip = data.resets_clip();
 }
 
 void ClipNodeData::AsValueInto(base::trace_event::TracedValue* value) const {
   MathUtil::AddToTracedValue("clip", clip, value);
   value->SetInteger("transform_id", transform_id);
-  value->SetInteger("target_id", target_id);
+  value->SetInteger("target_transform_id", target_transform_id);
+  value->SetInteger("target_effect_id", target_effect_id);
   value->SetBoolean("applies_local_clip", applies_local_clip);
   value->SetBoolean("layer_clipping_uses_only_local_clip",
                     layer_clipping_uses_only_local_clip);
   value->SetBoolean("target_is_clipped", target_is_clipped);
   value->SetBoolean("layers_are_clipped", layers_are_clipped);
   value->SetBoolean("layers_are_clipped_when_surfaces_disabled",
                     layers_are_clipped_when_surfaces_disabled);
   value->SetBoolean("resets_clip", resets_clip);
 }
 
@@ skipping 1980 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