cc: Remove SetNeedsCommitNoRebuild from Layer API

cc/trees/property_tree.h

 // Copyright 2014 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 64 matching lines @@
 
   T* parent(const T* t) { return Node(t->parent_id); }
   const T* parent(const T* t) const { return Node(t->parent_id); }
 
   T* back() { return size() ? &nodes_.back() : nullptr; }
   const T* back() const { return size() ? &nodes_.back() : nullptr; }
 
   void clear();
   size_t size() const { return nodes_.size(); }
 
-  void set_needs_update(bool needs_update) { needs_update_ = needs_update; }
+  virtual void set_needs_update(bool needs_update) {
+    needs_update_ = needs_update;
+  }
   bool needs_update() const { return needs_update_; }
 
   std::vector<T>& nodes() { return nodes_; }
   const std::vector<T>& nodes() const { return nodes_; }
 
   int next_available_id() const { return static_cast<int>(size()); }
 
   void SetPropertyTrees(PropertyTrees* property_trees) {
     property_trees_ = property_trees;
   }
   PropertyTrees* property_trees() const { return property_trees_; }
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
-  T* FindNodeFromOwningLayerId(int id) {
+  const T* FindNodeFromOwningLayerId(int id) const {
     return Node(FindNodeIndexFromOwningLayerId(id));
   }
+  T* UpdateNodeFromOwningLayerId(int id) {
+    int index = FindNodeIndexFromOwningLayerId(id);
+    if (index == kInvalidNodeId && property_trees()->is_main_thread) {
+      property_trees()->needs_rebuild = true;
+    }
+
+    return Node(index);
+  }
+
   int FindNodeIndexFromOwningLayerId(int id) const {
     auto iter = owning_layer_id_to_node_index.find(id);
     if (iter == owning_layer_id_to_node_index.end())
       return kInvalidNodeId;
     else
       return iter->second;
   }
 
   void SetOwningLayerIdForNode(const T* node, int id) {
     if (!node) {
@@ skipping 63 matching lines @@
   void ResetChangeTracking();
   // Updates the parent, target, and screen space transforms and snapping.
   void UpdateTransforms(int id);
   void UpdateTransformChanged(TransformNode* node,
                               TransformNode* parent_node,
                               TransformNode* source_node);
   void UpdateNodeAndAncestorsAreAnimatedOrInvertible(
       TransformNode* node,
       TransformNode* parent_node);
 
-  void set_needs_update(bool needs_update);
+  void set_needs_update(bool needs_update) final;
 
   // A TransformNode's source_to_parent value is used to account for the fact
   // that fixed-position layers are positioned by Blink wrt to their layer tree
   // parent (their "source"), but are parented in the transform tree by their
   // fixed-position container. This value needs to be updated on main-thread
   // property trees (for position changes initiated by Blink), but not on the
   // compositor thread (since the offset from a node corresponding to a
   // fixed-position layer to its fixed-position container is unaffected by
   // compositor-driven effects).
   void set_source_to_parent_updates_allowed(bool allowed) {
@@ skipping 480 matching lines @@
   DrawTransforms& GetDrawTransforms(int transform_id, int effect_id) const;
   DrawTransformData& FetchDrawTransformsDataFromCache(int transform_id,
                                                       int effect_id) const;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_