cc: Remove SetNeedsCommitNoRebuild from Layer API

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 467 matching lines @@
 }
 
 int LayerImpl::num_copy_requests_in_target_subtree() {
   return GetEffectTree()
       .Node(effect_tree_index())
       ->num_copy_requests_in_subtree;
 }
 
 void LayerImpl::UpdatePropertyTreeTransformIsAnimated(bool is_animated) {
   if (TransformNode* node =
-          GetTransformTree().FindNodeFromOwningLayerId(id())) {
+          GetTransformTree().UpdateNodeFromOwningLayerId(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 21 matching lines @@
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnIsAnimatingChanged(const PropertyAnimationState& mask,
                                      const PropertyAnimationState& state) {
   DCHECK(layer_tree_impl_);
 
-  TransformNode* transform_node =
-      GetTransformTree().FindNodeFromOwningLayerId(id());
-  EffectNode* effect_node = GetEffectTree().FindNodeFromOwningLayerId(id());
   for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
        property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
+    if (!mask.currently_running[property] &&
+        !mask.potentially_animating[property])
+      continue;
+
     switch (property) {
       case TargetProperty::TRANSFORM:
-        if (transform_node) {
+        if (TransformNode* transform_node =
+                GetTransformTree().UpdateNodeFromOwningLayerId(id())) {
           if (mask.currently_running[property])
             transform_node->is_currently_animating =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             UpdatePropertyTreeTransformIsAnimated(
                 state.potentially_animating[property]);
             was_ever_ready_since_last_transform_animation_ = false;
           }
         }
         break;
       case TargetProperty::OPACITY:
-        if (effect_node) {
+        if (EffectNode* effect_node =
+                GetEffectTree().UpdateNodeFromOwningLayerId(id())) {
           if (mask.currently_running[property])
             effect_node->is_currently_animating_opacity =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             effect_node->has_potential_opacity_animation =
                 state.potentially_animating[property];
             GetEffectTree().set_needs_update(true);
           }
         }
         break;
       case TargetProperty::FILTER:
-        if (effect_node) {
+        if (EffectNode* effect_node =
+                GetEffectTree().UpdateNodeFromOwningLayerId(id())) {
           if (mask.currently_running[property])
             effect_node->is_currently_animating_filter =
                 state.currently_running[property];
           if (mask.potentially_animating[property])
             effect_node->has_potential_filter_animation =
                 state.potentially_animating[property];
         }
         break;
       default:
         break;
@@ skipping 39 matching lines @@
     property_trees->SetInnerViewportContainerBoundsDelta(bounds_delta);
   else if (this == layer_tree_impl()->OuterViewportContainerLayer())
     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_EQ(clip_node, GetClipTree().FindNodeFromOwningLayerId(id()));
+    if (ClipNode* clip_node =
+            property_trees->clip_tree.UpdateNodeFromOwningLayerId(id())) {
+      DCHECK_EQ(clip_node->id, clip_tree_index());
       clip_node->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 43 matching lines @@
 
 void LayerImpl::SetMasksToBounds(bool masks_to_bounds) {
   masks_to_bounds_ = masks_to_bounds;
 }
 
 void LayerImpl::SetContentsOpaque(bool opaque) {
   contents_opaque_ = opaque;
 }
 
 float LayerImpl::Opacity() const {
-  if (EffectNode* node = GetEffectTree().FindNodeFromOwningLayerId(id()))
+  if (const EffectNode* node = GetEffectTree().FindNodeFromOwningLayerId(id()))
     return node->opacity;
   else
     return 1.f;
 }
 
 const gfx::Transform& LayerImpl::Transform() const {
   DCHECK_NE(GetTransformTree().FindNodeFromOwningLayerId(id()), nullptr);
   return GetTransformTree().FindNodeFromOwningLayerId(id())->local;
 }
 
@@ skipping 356 matching lines @@
 
 ScrollTree& LayerImpl::GetScrollTree() const {
   return GetPropertyTrees()->scroll_tree;
 }
 
 TransformTree& LayerImpl::GetTransformTree() const {
   return GetPropertyTrees()->transform_tree;
 }
 
 }  // namespace cc