Revert of cc : Add IsInIdtoIndexMap to property tres (patchset #4 id:60001 of https://codereview.ch…

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 101 matching lines @@
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
 }
 
 void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
   if (layer_tree_host_) {
-    layer_tree_host_->property_trees()->RemoveIdFromIdToIndexMaps(id());
     layer_tree_host_->property_trees()->needs_rebuild = true;
     layer_tree_host_->UnregisterLayer(this);
   }
   if (host) {
     host->property_trees()->needs_rebuild = true;
     host->RegisterLayer(this);
   }
 
   layer_tree_host_ = host;
   InvalidatePropertyTreesIndices();
@@ skipping 448 matching lines @@
 void Layer::SetPosition(const gfx::PointF& position) {
   DCHECK(IsPropertyChangeAllowed());
   if (position_ == position)
     return;
   position_ = position;
 
   if (!layer_tree_host_)
     return;
 
   SetSubtreePropertyChanged();
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                       id())) {
-    DCHECK_EQ(transform_tree_index(),
-              property_trees->transform_id_to_index_map[id()]);
-    TransformNode* transform_node =
-        property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->data.update_post_local_transform(position,
-                                                     transform_origin());
-    transform_node->data.needs_local_transform_update = true;
-    transform_node->data.transform_changed = true;
-    layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-    SetNeedsCommitNoRebuild();
-    return;
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.update_post_local_transform(position,
+                                                       transform_origin());
+      transform_node->data.needs_local_transform_update = true;
+      transform_node->data.transform_changed = true;
+      layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
+      SetNeedsCommitNoRebuild();
+      return;
+    }
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   if (!transform_.IsIdentityOrTranslation())
     return true;
   if (parent_ && !parent_->transform_.IsIdentityOrTranslation())
     return true;
@@ skipping 15 matching lines @@
   }
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
 
   SetSubtreePropertyChanged();
   if (layer_tree_host_) {
-    PropertyTrees* property_trees = layer_tree_host_->property_trees();
-    if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                         id())) {
-      // We need to trigger a rebuild if we could have affected 2d axis
-      // alignment. We'll check to see if transform and transform_ are axis
-      // align with respect to one another.
-      DCHECK_EQ(transform_tree_index(),
-                property_trees->transform_id_to_index_map[id()]);
-      TransformNode* transform_node =
-          property_trees->transform_tree.Node(transform_tree_index());
-      bool preserves_2d_axis_alignment =
-          Are2dAxisAligned(transform_, transform);
-      transform_node->data.local = transform;
-      transform_node->data.needs_local_transform_update = true;
-      transform_node->data.transform_changed = true;
-      layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-      if (preserves_2d_axis_alignment)
-        SetNeedsCommitNoRebuild();
-      else
-        SetNeedsCommit();
-      transform_ = transform;
-      return;
+    if (TransformNode* transform_node =
+            layer_tree_host_->property_trees()->transform_tree.Node(
+                transform_tree_index())) {
+      if (transform_node->owner_id == id()) {
+        // We need to trigger a rebuild if we could have affected 2d axis
+        // alignment. We'll check to see if transform and transform_ are axis
+        // align with respect to one another.
+        bool preserves_2d_axis_alignment =
+            Are2dAxisAligned(transform_, transform);
+        transform_node->data.local = transform;
+        transform_node->data.needs_local_transform_update = true;
+        transform_node->data.transform_changed = true;
+        layer_tree_host_->property_trees()->transform_tree.set_needs_update(
+            true);
+        if (preserves_2d_axis_alignment)
+          SetNeedsCommitNoRebuild();
+        else
+          SetNeedsCommit();
+        transform_ = transform;
+        return;
+      }
     }
   }
 
   transform_ = transform;
 
   SetNeedsCommit();
 }
 
 void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
 
   if (!layer_tree_host_)
     return;
 
   SetSubtreePropertyChanged();
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                       id())) {
-    DCHECK_EQ(transform_tree_index(),
-              property_trees->transform_id_to_index_map[id()]);
-    TransformNode* transform_node =
-        property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->data.update_pre_local_transform(transform_origin);
-    transform_node->data.update_post_local_transform(position(),
-                                                     transform_origin);
-    transform_node->data.needs_local_transform_update = true;
-    transform_node->data.transform_changed = true;
-    layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-    SetNeedsCommitNoRebuild();
-    return;
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.update_pre_local_transform(transform_origin);
+      transform_node->data.update_post_local_transform(position(),
+                                                       transform_origin);
+      transform_node->data.needs_local_transform_update = true;
+      transform_node->data.transform_changed = true;
+      layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
+      SetNeedsCommitNoRebuild();
+      return;
+    }
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::AnimationsPreserveAxisAlignment() const {
   DCHECK(layer_tree_host_);
   return layer_tree_host_->AnimationsPreserveAxisAlignment(this);
 }
 
@@ skipping 93 matching lines @@
 void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
 
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
 
   if (!layer_tree_host_)
     return;
 
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (scroll_tree_index() != -1 && scrollable())
-    property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
+    layer_tree_host_->property_trees()->scroll_tree.SetScrollOffset(
+        id(), scroll_offset);
 
-  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                       id())) {
-    DCHECK_EQ(transform_tree_index(),
-              property_trees->transform_id_to_index_map[id()]);
-    TransformNode* transform_node =
-        property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->data.scroll_offset = CurrentScrollOffset();
-    transform_node->data.needs_local_transform_update = true;
-    property_trees->transform_tree.set_needs_update(true);
-    SetNeedsCommitNoRebuild();
-    return;
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.scroll_offset = CurrentScrollOffset();
+      transform_node->data.needs_local_transform_update = true;
+      layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
+      SetNeedsCommitNoRebuild();
+      return;
+    }
   }
 
   SetNeedsCommit();
 }
 
 void Layer::SetScrollOffsetFromImplSide(
     const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
 
   bool needs_rebuild = true;
 
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (scroll_tree_index() != -1 && scrollable())
-    property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
+    layer_tree_host_->property_trees()->scroll_tree.SetScrollOffset(
+        id(), scroll_offset);
 
-  if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                       id())) {
-    DCHECK_EQ(transform_tree_index(),
-              property_trees->transform_id_to_index_map[id()]);
-    TransformNode* transform_node =
-        property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->data.scroll_offset = CurrentScrollOffset();
-    transform_node->data.needs_local_transform_update = true;
-    property_trees->transform_tree.set_needs_update(true);
-    needs_rebuild = false;
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.scroll_offset = CurrentScrollOffset();
+      transform_node->data.needs_local_transform_update = true;
+      layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
+      needs_rebuild = false;
+    }
   }
 
   if (needs_rebuild)
-    property_trees->needs_rebuild = true;
+    layer_tree_host_->property_trees()->needs_rebuild = true;
 
   if (!did_scroll_callback_.is_null())
     did_scroll_callback_.Run();
   // The callback could potentially change the layer structure:
   // "this" may have been destroyed during the process.
 }
 
 void Layer::SetScrollClipLayerId(int clip_layer_id) {
   DCHECK(IsPropertyChangeAllowed());
   if (scroll_clip_layer_id_ == clip_layer_id)
@@ skipping 744 matching lines @@
 }
 
 void Layer::OnOpacityAnimated(float opacity) {
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   // Changing the opacity may make a previously hidden layer visible, so a new
   // recording may be needed.
   SetNeedsUpdate();
   if (layer_tree_host_) {
-    PropertyTrees* property_trees = layer_tree_host_->property_trees();
-    if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT,
-                                         id())) {
-      DCHECK_EQ(effect_tree_index(),
-                property_trees->effect_id_to_index_map[id()]);
-      EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
-      node->data.opacity = opacity;
-      property_trees->effect_tree.set_needs_update(true);
+    if (EffectNode* node = layer_tree_host_->property_trees()->effect_tree.Node(
+            effect_tree_index())) {
+      if (node->owner_id == id()) {
+        node->data.opacity = opacity;
+        layer_tree_host_->property_trees()->effect_tree.set_needs_update(true);
+      }
     }
   }
 }
 
 void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
   transform_ = transform;
   // Changing the transform may change the visible part of this layer, so a new
   // recording may be needed.
   SetNeedsUpdate();
   if (layer_tree_host_) {
-    PropertyTrees* property_trees = layer_tree_host_->property_trees();
-    if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                         id())) {
-      DCHECK_EQ(transform_tree_index(),
-                property_trees->transform_id_to_index_map[id()]);
-      TransformNode* node =
-          property_trees->transform_tree.Node(transform_tree_index());
-      node->data.local = transform;
-      node->data.needs_local_transform_update = true;
-      node->data.has_potential_animation = true;
-      property_trees->transform_tree.set_needs_update(true);
+    if (TransformNode* node =
+            layer_tree_host_->property_trees()->transform_tree.Node(
+                transform_tree_index())) {
+      if (node->owner_id == id()) {
+        node->data.local = transform;
+        node->data.needs_local_transform_update = true;
+        node->data.has_potential_animation = true;
+        layer_tree_host_->property_trees()->transform_tree.set_needs_update(
+            true);
+      }
     }
   }
 }
 
 void Layer::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Do nothing. Scroll deltas will be sent from the compositor thread back
   // to the main thread in the same manner as during non-animated
   // compositor-driven scrolling.
 }
 
 void Layer::OnTransformIsCurrentlyAnimatingChanged(
     bool is_currently_animating) {
   DCHECK(layer_tree_host_);
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                        id()))
+  TransformTree& transform_tree =
+      layer_tree_host_->property_trees()->transform_tree;
+  TransformNode* node = transform_tree.Node(transform_tree_index());
+  if (!node)
     return;
-  DCHECK_EQ(transform_tree_index(),
-            property_trees->transform_id_to_index_map[id()]);
-  TransformNode* node =
-      property_trees->transform_tree.Node(transform_tree_index());
-  node->data.is_currently_animating = is_currently_animating;
+
+  if (node->owner_id == id())
+    node->data.is_currently_animating = is_currently_animating;
 }
 
 void Layer::OnTransformIsPotentiallyAnimatingChanged(
     bool has_potential_animation) {
   if (!layer_tree_host_)
     return;
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
-                                        id()))
+  TransformTree& transform_tree =
+      layer_tree_host_->property_trees()->transform_tree;
+  TransformNode* node = transform_tree.Node(transform_tree_index());
+  if (!node)
     return;
-  DCHECK_EQ(transform_tree_index(),
-            property_trees->transform_id_to_index_map[id()]);
-  TransformNode* node =
-      property_trees->transform_tree.Node(transform_tree_index());
 
-  node->data.has_potential_animation = has_potential_animation;
-  if (has_potential_animation) {
-    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
+  if (node->owner_id == id()) {
+    node->data.has_potential_animation = has_potential_animation;
+    if (has_potential_animation) {
+      float maximum_target_scale = 0.f;
+      node->data.local_maximum_animation_target_scale =
+          MaximumTargetScale(&maximum_target_scale) ? maximum_target_scale
                                                     : 0.f;
 
-    node->data.has_only_translation_animations = HasOnlyTranslationTransforms();
+      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;
     }
-    property_trees->transform_tree.set_needs_update(true);
+    transform_tree.set_needs_update(true);
+  }
 }
 
 void Layer::OnOpacityIsCurrentlyAnimatingChanged(bool is_currently_animating) {
   DCHECK(layer_tree_host_);
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+  EffectTree& effect_tree = layer_tree_host_->property_trees()->effect_tree;
+  EffectNode* node = effect_tree.Node(effect_tree_index());
+  if (!node)
     return;
-  DCHECK_EQ(effect_tree_index(), property_trees->effect_id_to_index_map[id()]);
-  EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
-  node->data.is_currently_animating_opacity = is_currently_animating;
+
+  if (node->owner_id == id())
+    node->data.is_currently_animating_opacity = is_currently_animating;
 }
 
 void Layer::OnOpacityIsPotentiallyAnimatingChanged(
     bool has_potential_animation) {
   DCHECK(layer_tree_host_);
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+  EffectTree& effect_tree = layer_tree_host_->property_trees()->effect_tree;
+  EffectNode* node = effect_tree.Node(effect_tree_index());
+  if (!node)
     return;
-  DCHECK_EQ(effect_tree_index(), property_trees->effect_id_to_index_map[id()]);
-  EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
-  node->data.has_potential_opacity_animation =
-      has_potential_animation || OpacityCanAnimateOnImplThread();
-  property_trees->effect_tree.set_needs_update(true);
+  if (node->owner_id == id()) {
+    node->data.has_potential_opacity_animation =
+        has_potential_animation || OpacityCanAnimateOnImplThread();
+    effect_tree.set_needs_update(true);
+  }
 }
 
 bool Layer::HasActiveAnimationForTesting() const {
   return layer_tree_host_ ? layer_tree_host_->HasActiveAnimationForTesting(this)
                           : false;
 }
 
 void Layer::SetHasWillChangeTransformHint(bool has_will_change) {
   if (has_will_change_transform_hint_ == has_will_change)
     return;
@@ skipping 81 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc