cc: Remove SetNeedsCommitNoRebuild from Layer API

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 11 matching lines @@
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/mutable_properties.h"
 #include "cc/trees/mutator_host.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 base::StaticAtomicSequenceNumber g_next_layer_id;
 
 Layer::Inputs::Inputs(int layer_id)
@@ skipping 42 matching lines @@
       clip_tree_index_(ClipTree::kInvalidNodeId),
       scroll_tree_index_(ScrollTree::kInvalidNodeId),
       property_tree_sequence_number_(-1),
       should_flatten_transform_from_property_tree_(false),
       draws_content_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       force_render_surface_for_testing_(false),
       subtree_property_changed_(false),
       may_contain_video_(false),
+      is_scroll_clip_layer_(false),
       safe_opaque_background_color_(0),
       draw_blend_mode_(SkBlendMode::kSrcOver),
       num_unclipped_descendants_(0) {}
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
   // Similarly we shouldn't have a layer tree host since it also keeps a
   // reference to us.
@@ skipping 50 matching lines @@
 
   if (host && has_any_animation)
     host->SetNeedsCommit();
 }
 
 void Layer::SetNeedsCommit() {
   if (!layer_tree_host_)
     return;
 
   SetNeedsPushProperties();
-  layer_tree_host_->property_trees()->needs_rebuild = true;
-
-  if (ignore_set_needs_commit_)
-    return;
-
-  layer_tree_host_->SetNeedsCommit();
-}
-
-void Layer::SetNeedsCommitNoRebuild() {
-  if (!layer_tree_host_)
-    return;
-
-  SetNeedsPushProperties();
 
   if (ignore_set_needs_commit_)
     return;
 
   layer_tree_host_->SetNeedsCommit();
 }
 
 void Layer::SetNeedsFullTreeSync() {
   if (!layer_tree_host_)
     return;
@@ skipping 28 matching lines @@
 sk_sp<SkPicture> Layer::GetPicture() const {
   return nullptr;
 }
 
 void Layer::SetParent(Layer* layer) {
   DCHECK(!layer || !layer->HasAncestor(this));
 
   parent_ = layer;
   SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : nullptr);
 
-  if (!layer_tree_host_)
-    return;
-
-  layer_tree_host_->property_trees()->needs_rebuild = true;
+  SetPropertyTreesNeedRebuild();
 }
 
 void Layer::AddChild(scoped_refptr<Layer> child) {
   InsertChild(child, inputs_.children.size());
 }
 
 void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) {
   DCHECK(IsPropertyChangeAllowed());
   child->RemoveFromParent();
   AddDrawableDescendants(child->NumDescendantsThatDrawContent() +
@@ skipping 60 matching lines @@
 
 void Layer::SetBounds(const gfx::Size& size) {
   DCHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
   inputs_.bounds = size;
 
   if (!layer_tree_host_)
     return;
 
-  if (masks_to_bounds())
+  if (masks_to_bounds()) {
     SetSubtreePropertyChanged();
+    SetPropertyTreesNeedRebuild();
+  }
+
+  if (scrollable()) {
+    if (ScrollNode* node =
+            layer_tree_host_->property_trees()
+                ->scroll_tree.UpdateNodeFromOwningLayerId(id())) {
+      node->bounds = inputs_.bounds;
+    }
+  }
+
+  if (is_scroll_clip_layer_)
+    layer_tree_host_->property_trees()->scroll_tree.set_needs_update(true);
+
   SetNeedsCommit();
 }
 
 Layer* Layer::RootLayer() {
   Layer* layer = this;
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
@@ skipping 33 matching lines @@
                      [&source](const std::unique_ptr<CopyOutputRequest>& x) {
                        return x->has_source() && x->source() == source;
                      });
     if (it != inputs_.copy_requests.end())
       inputs_.copy_requests.erase(it);
   }
   if (request->IsEmpty())
     return;
   inputs_.copy_requests.push_back(std::move(request));
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetBackgroundColor(SkColor background_color) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.background_color == background_color)
     return;
   inputs_.background_color = background_color;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetSafeOpaqueBackgroundColor(SkColor background_color) {
   DCHECK(IsPropertyChangeAllowed());
   if (safe_opaque_background_color_ == background_color)
     return;
   safe_opaque_background_color_ = background_color;
   SetNeedsPushProperties();
 }
 
 SkColor Layer::SafeOpaqueBackgroundColor() const {
   if (contents_opaque())
     return safe_opaque_background_color_;
   SkColor color = background_color();
   if (SkColorGetA(color) == 255)
     color = SK_ColorTRANSPARENT;
   return color;
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.masks_to_bounds == masks_to_bounds)
     return;
   inputs_.masks_to_bounds = masks_to_bounds;
   SetNeedsCommit();
+  SetPropertyTreesNeedRebuild();
   SetSubtreePropertyChanged();
 }
 
 void Layer::SetMaskLayer(Layer* mask_layer) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.mask_layer.get() == mask_layer)
     return;
   if (inputs_.mask_layer.get()) {
     DCHECK_EQ(this, inputs_.mask_layer->parent());
     inputs_.mask_layer->RemoveFromParent();
@@ skipping 22 matching lines @@
 
 void Layer::SetFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.filters == filters)
     return;
   inputs_.filters = filters;
   if (inputs_.mask_layer)
     inputs_.mask_layer->SetLayerMaskType(
         Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.background_filters == filters)
     return;
   inputs_.background_filters = filters;
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetFiltersOrigin(const gfx::PointF& filters_origin) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.filters_origin == filters_origin)
     return;
   inputs_.filters_origin = filters_origin;
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetOpacity(float opacity) {
   DCHECK(IsPropertyChangeAllowed());
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
 
   if (inputs_.opacity == opacity)
     return;
   // We need to force a property tree rebuild when opacity changes from 1 to a
   // non-1 value or vice-versa as render surfaces can change.
   bool force_rebuild = opacity == 1.f || inputs_.opacity == 1.f;
   inputs_.opacity = opacity;
   SetSubtreePropertyChanged();
   if (layer_tree_host_ && !force_rebuild) {
     PropertyTrees* property_trees = layer_tree_host_->property_trees();
     if (EffectNode* node =
-            property_trees->effect_tree.FindNodeFromOwningLayerId(id())) {
+            property_trees->effect_tree.UpdateNodeFromOwningLayerId(id())) {
       node->opacity = opacity;
       node->effect_changed = true;
       property_trees->effect_tree.set_needs_update(true);
-      SetNeedsCommitNoRebuild();
-      return;
     }
   }
+  if (force_rebuild)
+    SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 float Layer::EffectiveOpacity() const {
   return inputs_.hide_layer_and_subtree ? 0.f : inputs_.opacity;
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
@@ skipping 44 matching lines @@
     case SkBlendMode::kModulate:
       // Porter Duff Compositing Operators are not yet supported
       // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators
       NOTREACHED();
       return;
   }
 
   inputs_.blend_mode = blend_mode;
   SetNeedsCommit();
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
 }
 
 void Layer::SetIsRootForIsolatedGroup(bool root) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.is_root_for_isolated_group == root)
     return;
   inputs_.is_root_for_isolated_group = root;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetContentsOpaque(bool opaque) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.contents_opaque == opaque)
     return;
   inputs_.contents_opaque = opaque;
   SetNeedsCommit();
   SetSubtreePropertyChanged();
+  SetPropertyTreesNeedRebuild();
 }
 
 void Layer::SetPosition(const gfx::PointF& position) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.position == position)
     return;
   inputs_.position = position;
 
   if (!layer_tree_host_)
     return;
 
   SetSubtreePropertyChanged();
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (TransformNode* transform_node =
-          property_trees->transform_tree.FindNodeFromOwningLayerId(id())) {
+          property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
     DCHECK_EQ(transform_tree_index(), transform_node->id);
     transform_node->update_post_local_transform(position, transform_origin());
     if (transform_node->sticky_position_constraint_id >= 0) {
       StickyPositionNodeData* sticky_data =
           property_trees->transform_tree.StickyPositionData(
               transform_tree_index());
       sticky_data->main_thread_offset =
           position.OffsetFromOrigin() -
           sticky_data->constraints.parent_relative_sticky_box_offset
               .OffsetFromOrigin();
     }
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-    SetNeedsCommitNoRebuild();
-    return;
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   return inputs_.is_container_for_fixed_position_layers;
 }
 
 bool Are2dAxisAligned(const gfx::Transform& a, const gfx::Transform& b) {
@@ skipping 13 matching lines @@
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.transform == transform)
     return;
 
   SetSubtreePropertyChanged();
   if (layer_tree_host_) {
     PropertyTrees* property_trees = layer_tree_host_->property_trees();
     if (TransformNode* transform_node =
-            property_trees->transform_tree.FindNodeFromOwningLayerId(id())) {
+            property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
       // We need to trigger a rebuild if we could have affected 2d axis
       // alignment. We'll check to see if transform and inputs_.transform are
       // axis align with respect to one another.
       DCHECK_EQ(transform_tree_index(), transform_node->id);
       bool preserves_2d_axis_alignment =
           Are2dAxisAligned(inputs_.transform, transform);
       transform_node->local = transform;
       transform_node->needs_local_transform_update = true;
       transform_node->transform_changed = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-      if (preserves_2d_axis_alignment)
-        SetNeedsCommitNoRebuild();
-      else
-        SetNeedsCommit();
-      inputs_.transform = transform;
-      return;
+      if (!preserves_2d_axis_alignment)
+        SetPropertyTreesNeedRebuild();
     }
   }
 
   inputs_.transform = transform;
 
   SetNeedsCommit();
 }
 
 void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.transform_origin == transform_origin)
     return;
   inputs_.transform_origin = transform_origin;
 
   if (!layer_tree_host_)
     return;
 
   SetSubtreePropertyChanged();
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (TransformNode* transform_node =
-          property_trees->transform_tree.FindNodeFromOwningLayerId(id())) {
+          property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
     DCHECK_EQ(transform_tree_index(), transform_node->id);
     transform_node->update_pre_local_transform(transform_origin);
     transform_node->update_post_local_transform(position(), transform_origin);
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
-    SetNeedsCommitNoRebuild();
-    return;
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::ScrollOffsetAnimationWasInterrupted() const {
   return GetMutatorHost()->ScrollOffsetAnimationWasInterrupted(element_id());
 }
 
 bool Layer::HasOnlyTranslationTransforms() const {
   return GetMutatorHost()->HasOnlyTranslationTransforms(
       element_id(), GetElementTypeForAnimation());
 }
 
 void Layer::SetScrollParent(Layer* parent) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.scroll_parent == parent)
     return;
 
   if (inputs_.scroll_parent)
     inputs_.scroll_parent->RemoveScrollChild(this);
 
   inputs_.scroll_parent = parent;
 
   if (inputs_.scroll_parent)
     inputs_.scroll_parent->AddScrollChild(this);
 
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::AddScrollChild(Layer* child) {
   if (!scroll_children_)
     scroll_children_.reset(new std::set<Layer*>);
   scroll_children_->insert(child);
   SetNeedsCommit();
 }
 
@@ skipping 10 matching lines @@
     return;
 
   if (inputs_.clip_parent)
     inputs_.clip_parent->RemoveClipChild(this);
 
   inputs_.clip_parent = ancestor;
 
   if (inputs_.clip_parent)
     inputs_.clip_parent->AddClipChild(this);
 
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsMetaInfoRecomputation(true);
 }
 
 void Layer::AddClipChild(Layer* child) {
   if (!clip_children_)
     clip_children_.reset(new std::set<Layer*>);
   clip_children_->insert(child);
   SetNeedsCommit();
@@ skipping 14 matching lines @@
   inputs_.scroll_offset = scroll_offset;
 
   if (!layer_tree_host_)
     return;
 
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable())
     property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
 
   if (TransformNode* transform_node =
-          property_trees->transform_tree.FindNodeFromOwningLayerId(id())) {
+          property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
     DCHECK_EQ(transform_tree_index(), transform_node->id);
     transform_node->scroll_offset = CurrentScrollOffset();
     transform_node->needs_local_transform_update = true;
     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 (inputs_.scroll_offset == scroll_offset)
     return;
   inputs_.scroll_offset = scroll_offset;
   SetNeedsPushProperties();
 
-  bool needs_rebuild = true;
-
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable())
     property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
 
   if (TransformNode* transform_node =
-          property_trees->transform_tree.FindNodeFromOwningLayerId(id())) {
+          property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
     DCHECK_EQ(transform_tree_index(), transform_node->id);
     transform_node->scroll_offset = CurrentScrollOffset();
     transform_node->needs_local_transform_update = true;
     property_trees->transform_tree.set_needs_update(true);
-    needs_rebuild = false;
   }
 
-  if (needs_rebuild)
-    property_trees->needs_rebuild = true;
-
   if (!inputs_.did_scroll_callback.is_null())
     inputs_.did_scroll_callback.Run(scroll_offset);
 
   // 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 (inputs_.scroll_clip_layer_id == clip_layer_id)
     return;
   inputs_.scroll_clip_layer_id = clip_layer_id;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 Layer* Layer::scroll_clip_layer() const {
   DCHECK(layer_tree_host_);
   return layer_tree_host_->LayerById(inputs_.scroll_clip_layer_id);
 }
 
 void Layer::SetUserScrollable(bool horizontal, bool vertical) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.user_scrollable_horizontal == horizontal &&
       inputs_.user_scrollable_vertical == vertical)
     return;
   inputs_.user_scrollable_horizontal = horizontal;
   inputs_.user_scrollable_vertical = vertical;
+  if (!layer_tree_host_)
+    return;
+
+  if (ScrollNode* node = layer_tree_host_->property_trees()
+                             ->scroll_tree.UpdateNodeFromOwningLayerId(id())) {
+    node->user_scrollable_horizontal = horizontal;
+    node->user_scrollable_vertical = vertical;
+  }
   SetNeedsCommit();
 }
 
 void Layer::AddMainThreadScrollingReasons(
     uint32_t main_thread_scrolling_reasons) {
   DCHECK(IsPropertyChangeAllowed());
   DCHECK(main_thread_scrolling_reasons);
   uint32_t new_reasons =
       inputs_.main_thread_scrolling_reasons | main_thread_scrolling_reasons;
   if (inputs_.main_thread_scrolling_reasons == new_reasons)
     return;
   inputs_.main_thread_scrolling_reasons = new_reasons;
   didUpdateMainThreadScrollingReasons();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::ClearMainThreadScrollingReasons(
     uint32_t main_thread_scrolling_reasons_to_clear) {
   DCHECK(IsPropertyChangeAllowed());
   DCHECK(main_thread_scrolling_reasons_to_clear);
   uint32_t new_reasons = ~main_thread_scrolling_reasons_to_clear &
                          inputs_.main_thread_scrolling_reasons;
   if (new_reasons == inputs_.main_thread_scrolling_reasons)
     return;
   inputs_.main_thread_scrolling_reasons = new_reasons;
   didUpdateMainThreadScrollingReasons();
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetNonFastScrollableRegion(const Region& region) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.non_fast_scrollable_region == region)
     return;
   inputs_.non_fast_scrollable_region = region;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetTouchEventHandlerRegion(const Region& region) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.touch_event_handler_region == region)
     return;
 
   inputs_.touch_event_handler_region = region;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetForceRenderSurfaceForTesting(bool force) {
   DCHECK(IsPropertyChangeAllowed());
   if (force_render_surface_for_testing_ == force)
     return;
   force_render_surface_for_testing_ = force;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetDoubleSided(bool double_sided) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.double_sided == double_sided)
     return;
   inputs_.double_sided = double_sided;
   SetNeedsCommit();
+  SetPropertyTreesNeedRebuild();
   SetSubtreePropertyChanged();
 }
 
 void Layer::Set3dSortingContextId(int id) {
   DCHECK(IsPropertyChangeAllowed());
   if (id == inputs_.sorting_context_id)
     return;
   inputs_.sorting_context_id = id;
   SetNeedsCommit();
+  SetPropertyTreesNeedRebuild();
   SetSubtreePropertyChanged();
 }
 
 void Layer::SetTransformTreeIndex(int index) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_tree_index_ == index)
     return;
   transform_tree_index_ = index;
   SetNeedsPushProperties();
 }
@@ skipping 58 matching lines @@
   return scroll_tree_index_;
 }
 
 void Layer::InvalidatePropertyTreesIndices() {
   SetTransformTreeIndex(TransformTree::kInvalidNodeId);
   SetClipTreeIndex(ClipTree::kInvalidNodeId);
   SetEffectTreeIndex(EffectTree::kInvalidNodeId);
   SetScrollTreeIndex(ScrollTree::kInvalidNodeId);
 }
 
+void Layer::SetPropertyTreesNeedRebuild() {
+  if (layer_tree_host_)
+    layer_tree_host_->property_trees()->needs_rebuild = true;
+}
+
 void Layer::SetShouldFlattenTransform(bool should_flatten) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.should_flatten_transform == should_flatten)
     return;
   inputs_.should_flatten_transform = should_flatten;
   SetNeedsCommit();
+  SetPropertyTreesNeedRebuild();
   SetSubtreePropertyChanged();
 }
 
 void Layer::SetUseParentBackfaceVisibility(bool use) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.use_parent_backface_visibility == use)
     return;
   inputs_.use_parent_backface_visibility = use;
   SetNeedsPushProperties();
 }
@@ skipping 22 matching lines @@
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void Layer::SetHideLayerAndSubtree(bool hide) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.hide_layer_and_subtree == hide)
     return;
 
   inputs_.hide_layer_and_subtree = hide;
   SetNeedsCommit();
+  SetPropertyTreesNeedRebuild();
   SetSubtreePropertyChanged();
 }
 
 void Layer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
   if (dirty_rect.IsEmpty())
     return;
 
   SetNeedsPushProperties();
   inputs_.update_rect.Union(dirty_rect);
 
@@ skipping 12 matching lines @@
 
 void Layer::SetIsContainerForFixedPositionLayers(bool container) {
   if (inputs_.is_container_for_fixed_position_layers == container)
     return;
   inputs_.is_container_for_fixed_position_layers = container;
 
   if (layer_tree_host_ && layer_tree_host_->CommitRequested())
     return;
 
   // Only request a commit if we have a fixed positioned descendant.
-  if (DescendantIsFixedToContainerLayer())
+  if (DescendantIsFixedToContainerLayer()) {
+    SetPropertyTreesNeedRebuild();
     SetNeedsCommit();
+  }
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.position_constraint == constraint)
     return;
   inputs_.position_constraint = constraint;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 void Layer::SetStickyPositionConstraint(
     const LayerStickyPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.sticky_position_constraint == constraint)
     return;
   inputs_.sticky_position_constraint = constraint;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 static void RunCopyCallbackOnMainThread(
     std::unique_ptr<CopyOutputRequest> request,
     std::unique_ptr<CopyOutputResult> result) {
   request->SendResult(std::move(result));
 }
 
 static void PostCopyCallbackToMainThread(
@@ skipping 130 matching lines @@
 void Layer::UpdateDrawsContent(bool has_drawable_content) {
   bool draws_content = has_drawable_content;
   DCHECK(inputs_.is_drawable || !has_drawable_content);
   if (draws_content == draws_content_)
     return;
 
   if (parent())
     parent()->AddDrawableDescendants(draws_content ? 1 : -1);
 
   draws_content_ = draws_content;
+  SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
 int Layer::NumDescendantsThatDrawContent() const {
   return num_descendants_that_draw_content_;
 }
 
 void Layer::SavePaintProperties() {
   DCHECK(layer_tree_host_);
 
@@ skipping 81 matching lines @@
   // 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::OnIsAnimatingChanged(const PropertyAnimationState& mask,
                                  const PropertyAnimationState& state) {
   DCHECK(layer_tree_host_);
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
 
-  TransformNode* transform_node =
-      property_trees->transform_tree.FindNodeFromOwningLayerId(id());
-  DCHECK(!transform_node || transform_node->id == transform_tree_index());
-
-  EffectNode* effect_node =
-      property_trees->effect_tree.FindNodeFromOwningLayerId(id());
-  DCHECK(!effect_node || effect_node->id == effect_tree_index());
-
   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 =
+                property_trees->transform_tree.UpdateNodeFromOwningLayerId(
+                    id())) {
+          DCHECK_EQ(transform_node->id, transform_tree_index());
           if (mask.currently_running[property])
             transform_node->is_currently_animating =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             transform_node->has_potential_animation =
                 state.potentially_animating[property];
             if (state.potentially_animating[property]) {
               transform_node->has_only_translation_animations =
                   HasOnlyTranslationTransforms();
             } else {
               transform_node->has_only_translation_animations = true;
             }
             property_trees->transform_tree.set_needs_update(true);
           }
+        } else {
+          DCHECK(property_trees->needs_rebuild)
+              << "Attempting to animate non existent transform node";
         }
         break;
       case TargetProperty::OPACITY:
-        if (effect_node) {
+        if (EffectNode* effect_node =
+                property_trees->effect_tree.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] ||
                 OpacityCanAnimateOnImplThread();
             property_trees->effect_tree.set_needs_update(true);
           }
+        } else {
+          DCHECK(property_trees->needs_rebuild)
+              << "Attempting to animate opacity on non existent effect node";
         }
         break;
       case TargetProperty::FILTER:
-        if (effect_node) {
+        if (EffectNode* effect_node =
+                property_trees->effect_tree.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];
+        } else {
+          DCHECK(property_trees->needs_rebuild)
+              << "Attempting to animate filter on non existent effect node";
         }
         break;
       default:
         break;
     }
   }
 }
 
 bool Layer::HasTickingAnimationForTesting() const {
   return layer_tree_host_
@@ skipping 112 matching lines @@
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc