Clarify property tree id-to-index map names.

cc/layers/layer_impl.cc

 // Copyright 2012 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 "cc/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 487 matching lines @@
   return GetEffectTree()
       .Node(effect_tree_index())
       ->num_copy_requests_in_subtree;
 }
 
 void LayerImpl::UpdatePropertyTreeTransformIsAnimated(bool is_animated) {
   PropertyTrees* property_trees = GetPropertyTrees();
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     TransformTree& transform_tree = GetTransformTree();
-    TransformNode* node =
-        transform_tree.Node(property_trees->transform_id_to_index_map[id()]);
+    TransformNode* node = transform_tree.Node(
+        property_trees->layer_id_to_transform_node_index[id()]);
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns a TransformNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, if
     // |is_animated| is false, this might mean a transform animation just ticked
     // past its finish point (so the LayerImpl still owns a TransformNode) or it
     // might mean that a transform animation was removed during commit or
     // activation (and, in that case, the LayerImpl will no longer own a
     // TransformNode, unless it has non-animation-related reasons for owning a
     // node).
     if (node->has_potential_animation != is_animated) {
@@ skipping 26 matching lines @@
 
 void LayerImpl::OnIsAnimatingChanged(const PropertyAnimationState& mask,
                                      const PropertyAnimationState& state) {
   DCHECK(layer_tree_impl_);
   PropertyTrees* property_trees = GetPropertyTrees();
 
   TransformNode* transform_node = nullptr;
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     transform_node = GetTransformTree().Node(
-        property_trees->transform_id_to_index_map[id()]);
+        property_trees->layer_id_to_transform_node_index[id()]);
   }
 
   EffectNode* effect_node = nullptr;
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id())) {
-    effect_node =
-        GetEffectTree().Node(property_trees->effect_id_to_index_map[id()]);
+    effect_node = GetEffectTree().Node(
+        property_trees->layer_id_to_effect_node_index[id()]);
   }
 
   for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
        property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
     switch (property) {
       case TargetProperty::TRANSFORM:
         if (transform_node) {
           if (mask.currently_running[property])
             transform_node->is_currently_animating =
                 state.currently_running[property];
@@ skipping 141 matching lines @@
 
 void LayerImpl::SetContentsOpaque(bool opaque) {
   contents_opaque_ = opaque;
 }
 
 float LayerImpl::Opacity() const {
   PropertyTrees* property_trees = GetPropertyTrees();
   if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
     return 1.f;
   EffectNode* node =
-      GetEffectTree().Node(property_trees->effect_id_to_index_map[id()]);
+      GetEffectTree().Node(property_trees->layer_id_to_effect_node_index[id()]);
   return node->opacity;
 }
 
 const gfx::Transform& LayerImpl::Transform() const {
   PropertyTrees* property_trees = GetPropertyTrees();
   DCHECK(property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                           id()));
-  TransformNode* node =
-      GetTransformTree().Node(property_trees->transform_id_to_index_map[id()]);
+  TransformNode* node = GetTransformTree().Node(
+      property_trees->layer_id_to_transform_node_index[id()]);
   return node->local;
 }
 
 void LayerImpl::SetElementId(ElementId element_id) {
   if (element_id == element_id_)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerImpl::SetElementId", "element",
                element_id.AsValue().release());
@@ skipping 353 matching lines @@
 
 ScrollTree& LayerImpl::GetScrollTree() const {
   return GetPropertyTrees()->scroll_tree;
 }
 
 TransformTree& LayerImpl::GetTransformTree() const {
   return GetPropertyTrees()->transform_tree;
 }
 
 }  // namespace cc