cc : Add IsInIdtoIndexMap to property tres

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 606 matching lines @@
 }
 
 int LayerImpl::num_copy_requests_in_target_subtree() {
   return layer_tree_impl()
       ->property_trees()
       ->effect_tree.Node(effect_tree_index())
       ->data.num_copy_requests_in_subtree;
 }
 
 void LayerImpl::UpdatePropertyTreeTransform() {
-  if (transform_tree_index_ != -1) {
-    TransformTree& transform_tree =
-        layer_tree_impl()->property_trees()->transform_tree;
-    TransformNode* node = transform_tree.Node(transform_tree_index_);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
+                                       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, a
     // transform animation might have been in progress at the time the last
     // commit started, but might have finished since then on the compositor
     // thread.
-    if (node->owner_id != id())
-      return;
+    TransformNode* node =
+        property_trees->transform_tree.Node(transform_tree_index());
     if (node->data.local != transform_) {
       node->data.local = transform_;
       node->data.needs_local_transform_update = true;
       node->data.transform_changed = true;
-      layer_tree_impl()->property_trees()->changed = true;
-      transform_tree.set_needs_update(true);
+      property_trees->changed = true;
+      property_trees->transform_tree.set_needs_update(true);
       // TODO(ajuma): The current criteria for creating clip nodes means that
       // property trees may need to be rebuilt when the new transform isn't
       // axis-aligned wrt the old transform (see Layer::SetTransform). Since
       // rebuilding property trees every frame of a transform animation is
       // something we should try to avoid, change property tree-building so that
       // it doesn't depend on axis aliginment.
     }
   }
 }
 
 void LayerImpl::UpdatePropertyTreeTransformIsAnimated(bool is_animated) {
-  if (transform_tree_index_ != -1) {
-    TransformTree& transform_tree =
-        layer_tree_impl()->property_trees()->transform_tree;
-    TransformNode* node = transform_tree.Node(transform_tree_index_);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
+                                       id())) {
+    TransformNode* node = property_trees->transform_tree.Node(
+        property_trees->transform_id_to_index_map[id()]);

[jaydasika, 2016/05/19 22:16:22]

There is unit tests for which transform_tree_index = -1, but
property_trees->transform_id_to_index_map[id()] isn't, which is weird! That's
the reason we were having the check for -1. I will investigate that in a
different CL.

     // 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->owner_id != id())
-      return;
     if (node->data.has_potential_animation != is_animated) {
       node->data.has_potential_animation = is_animated;
       if (is_animated) {
         float maximum_target_scale = 0.f;
         node->data.local_maximum_animation_target_scale =
             MaximumTargetScale(&maximum_target_scale) ? maximum_target_scale
                                                       : 0.f;
 
         float animation_start_scale = 0.f;
         node->data.local_starting_animation_scale =
             AnimationStartScale(&animation_start_scale) ? animation_start_scale
                                                         : 0.f;
 
         node->data.has_only_translation_animations =
             HasOnlyTranslationTransforms();
       } else {
         node->data.local_maximum_animation_target_scale = 0.f;
         node->data.local_starting_animation_scale = 0.f;
         node->data.has_only_translation_animations = true;
       }
 
-      transform_tree.set_needs_update(true);
+      property_trees->transform_tree.set_needs_update(true);
       layer_tree_impl()->set_needs_update_draw_properties();
     }
   }
 }
 
 void LayerImpl::UpdatePropertyTreeOpacity() {
-  if (effect_tree_index_ != -1) {
-    EffectTree& effect_tree = layer_tree_impl()->property_trees()->effect_tree;
-    if (effect_tree_index_ >= static_cast<int>(effect_tree.size()))
-      return;
-    EffectNode* node = effect_tree.Node(effect_tree_index_);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id())) {
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns an OpacityNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, an
     // opacity animation might have been in progress at the time the last commit
     // started, but might have finished since then on the compositor thread.
-    if (node->owner_id != id() || node->data.opacity == opacity_)
-      return;
+    EffectNode* node = property_trees->effect_tree.Node(effect_tree_index_);
     node->data.opacity = opacity_;
     node->data.effect_changed = true;
-    layer_tree_impl()->property_trees()->changed = true;
-    effect_tree.set_needs_update(true);
+    property_trees->changed = true;
+    property_trees->effect_tree.set_needs_update(true);
   }
 }
 
 void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() {
   if (scrollable())
     UpdatePropertyTreeScrollOffset();
 
   if (HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM)) {
     UpdatePropertyTreeTransform();
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
   if (filters_ != filters) {
     SetFilters(filters);
     SetNeedsPushProperties();
     layer_tree_impl()->set_needs_update_draw_properties();
     EffectTree& effect_tree = layer_tree_impl()->property_trees()->effect_tree;
     EffectNode* node = effect_tree.Node(effect_tree_index_);
-    DCHECK_EQ(node->owner_id, id());
+    DCHECK(layer_tree_impl()->property_trees()->IsInIdToIndexMap(
+        PropertyTrees::TreeType::EFFECT, id()));
     node->data.effect_changed = true;
     layer_tree_impl()->property_trees()->changed = true;
     effect_tree.set_needs_update(true);
   }
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   SetOpacity(opacity);
   UpdatePropertyTreeOpacity();
   SetNeedsPushProperties();
@@ skipping 20 matching lines @@
     return;
 
   SetCurrentScrollOffset(ClampScrollOffsetToLimits(scroll_offset));
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
 
 void LayerImpl::OnTransformIsCurrentlyAnimatingChanged(
     bool is_currently_animating) {
   DCHECK(layer_tree_impl_);
-  TransformTree& transform_tree =
-      layer_tree_impl_->property_trees()->transform_tree;
-  TransformNode* node = transform_tree.Node(transform_tree_index());
-  if (!node)
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
+                                        id()))
     return;
-
-  if (node->owner_id == id())
-    node->data.is_currently_animating = is_currently_animating;
+  TransformNode* node = property_trees->transform_tree.Node(
+      property_trees->transform_id_to_index_map[id()]);
+  node->data.is_currently_animating = is_currently_animating;
 }
 
 void LayerImpl::OnTransformIsPotentiallyAnimatingChanged(
     bool has_potential_animation) {
   UpdatePropertyTreeTransformIsAnimated(has_potential_animation);
   was_ever_ready_since_last_transform_animation_ = false;
 }
 
 void LayerImpl::OnOpacityIsCurrentlyAnimatingChanged(
     bool is_currently_animating) {
   DCHECK(layer_tree_impl_);
-  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
-  EffectNode* node = effect_tree.Node(effect_tree_index());
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+    return;
+  EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
 
-  if (node->owner_id == id())
-    node->data.is_currently_animating_opacity = is_currently_animating;
+  node->data.is_currently_animating_opacity = is_currently_animating;
 }
 
 void LayerImpl::OnOpacityIsPotentiallyAnimatingChanged(
     bool has_potential_animation) {
   DCHECK(layer_tree_impl_);
-  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
-  EffectNode* node = effect_tree.Node(effect_tree_index());
-  if (node->owner_id == id()) {
-    node->data.has_potential_opacity_animation = has_potential_animation;
-    effect_tree.set_needs_update(true);
-  }
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+    return;
+  EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
+  node->data.has_potential_opacity_animation = has_potential_animation;
+  property_trees->effect_tree.set_needs_update(true);
 }
 
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
 gfx::Size LayerImpl::bounds() const {
   gfx::Vector2d delta = gfx::ToCeiledVector2d(bounds_delta_);
   return gfx::Size(bounds_.width() + delta.x(),
                    bounds_.height() + delta.y());
@@ skipping 29 matching lines @@
     property_trees->SetOuterViewportContainerBoundsDelta(bounds_delta);
   else if (this == layer_tree_impl()->InnerViewportScrollLayer())
     property_trees->SetInnerViewportScrollBoundsDelta(bounds_delta);
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
   if (masks_to_bounds()) {
     // If layer is clipping, then update the clip node using the new bounds.
     ClipNode* clip_node = property_trees->clip_tree.Node(clip_tree_index());
     if (clip_node) {
-      DCHECK(id() == clip_node->owner_id);
+      DCHECK(property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::CLIP,
+                                              id()));
       clip_node->data.clip = gfx::RectF(
           gfx::PointF() + offset_to_transform_parent(), gfx::SizeF(bounds()));
       property_trees->clip_tree.set_needs_update(true);
     }
     property_trees->full_tree_damaged = true;
     layer_tree_impl()->set_needs_update_draw_properties();
   } else {
     NoteLayerPropertyChanged();
   }
 }
@@ skipping 265 matching lines @@
 }
 
 gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
   return layer_tree_impl()->property_trees()->scroll_tree.current_scroll_offset(
       id());
 }
 
 void LayerImpl::UpdatePropertyTreeScrollOffset() {
   // TODO(enne): in the future, scrolling should update the scroll tree
   // directly instead of going through layers.
-  if (transform_tree_index_ != -1) {
     TransformTree& transform_tree =
         layer_tree_impl()->property_trees()->transform_tree;
     TransformNode* node = transform_tree.Node(transform_tree_index_);
     gfx::ScrollOffset current_offset = CurrentScrollOffset();
     if (node->data.scroll_offset != current_offset) {
       node->data.scroll_offset = current_offset;
       node->data.needs_local_transform_update = true;
       transform_tree.set_needs_update(true);
     }
-  }
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_layer_rect());
   return SimpleEnclosedRegion();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
@@ skipping 242 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc