cc: Remove SetNeedsCommitNoRebuild from Layer API

cc/trees/layer_tree_host.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 662 matching lines @@
       TRACE_EVENT_INSTANT1(
           "cc", "LayerTreeHostInProcess::UpdateLayers_BuiltPropertyTrees",
           TRACE_EVENT_SCOPE_THREAD, "property_trees",
           property_trees->AsTracedValue());
     } else {
       TRACE_EVENT_INSTANT1(
           "cc", "LayerTreeHostInProcess::UpdateLayers_ReceivedPropertyTrees",
           TRACE_EVENT_SCOPE_THREAD, "property_trees",
           property_trees->AsTracedValue());
     }
-    draw_property_utils::UpdatePropertyTrees(property_trees,
+    draw_property_utils::UpdatePropertyTrees(this, property_trees,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(this, property_trees,
                                                    &update_layer_list);
   }
 
   for (const auto& layer : update_layer_list)
     layer->SavePaintProperties();
 
   bool content_is_suitable_for_gpu = true;
   bool did_paint_content =
@@ skipping 540 matching lines @@
 void LayerTreeHost::SetElementOpacityMutated(ElementId element_id,
                                              ElementListType list_type,
                                              float opacity) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
   layer->OnOpacityAnimated(opacity);
 
   if (EffectNode* node =
-          property_trees_.effect_tree.FindNodeFromOwningLayerId(layer->id())) {
+          property_trees_.effect_tree.UpdateNodeFromOwningLayerId(
+              layer->id())) {
     DCHECK_EQ(layer->effect_tree_index(), node->id);
     if (node->opacity == opacity)
       return;
 
     node->opacity = opacity;
     property_trees_.effect_tree.set_needs_update(true);
   }
 
   SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetElementTransformMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::Transform& transform) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnTransformAnimated(transform);
 
   if (TransformNode* node =
-          property_trees_.transform_tree.FindNodeFromOwningLayerId(
+          property_trees_.transform_tree.UpdateNodeFromOwningLayerId(
               layer->id())) {
     DCHECK_EQ(layer->transform_tree_index(), node->id);
     if (node->local == transform)
       return;
 
     node->local = transform;
     node->needs_local_transform_update = true;
     node->has_potential_animation = true;
     property_trees_.transform_tree.set_needs_update(true);
   }
@@ skipping 50 matching lines @@
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 }  // namespace cc