cc: Move OnScrollOffsetAnimated to scroll tree

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3907 matching lines @@
 void LayerTreeHostImpl::SetMutatorsNeedRebuildPropertyTrees() {}
 
 void LayerTreeHostImpl::SetTreeLayerFilterMutated(
     ElementId element_id,
     LayerTreeImpl* tree,
     const FilterOperations& filters) {
   if (!tree)
     return;
 
   const int layer_id = tree->LayerIdByElementId(element_id);
+  DCHECK(tree->property_trees()->IsInIdToIndexMap(
+      PropertyTrees::TreeType::EFFECT, layer_id));
   const int effect_id =
       tree->property_trees()->effect_id_to_index_map[layer_id];
   if (effect_id != EffectTree::kInvalidNodeId)
     tree->property_trees()->effect_tree.OnFilterAnimated(filters, effect_id,
                                                          tree);
 }
 
 void LayerTreeHostImpl::SetTreeLayerOpacityMutated(ElementId element_id,
                                                    LayerTreeImpl* tree,
                                                    float opacity) {
   if (!tree)
     return;
 
   const int layer_id = tree->LayerIdByElementId(element_id);
+  DCHECK(tree->property_trees()->IsInIdToIndexMap(
+      PropertyTrees::TreeType::EFFECT, layer_id));
   const int effect_id =
       tree->property_trees()->effect_id_to_index_map[layer_id];
   if (effect_id != EffectTree::kInvalidNodeId)
     tree->property_trees()->effect_tree.OnOpacityAnimated(opacity, effect_id,
                                                           tree);
 }
 
 void LayerTreeHostImpl::SetTreeLayerTransformMutated(
     ElementId element_id,
     LayerTreeImpl* tree,
     const gfx::Transform& transform) {
   if (!tree)
     return;
 
   const int layer_id = tree->LayerIdByElementId(element_id);
+  DCHECK(tree->property_trees()->IsInIdToIndexMap(
+      PropertyTrees::TreeType::TRANSFORM, layer_id));
   const int transform_id =
       tree->property_trees()->transform_id_to_index_map[layer_id];
   if (transform_id != TransformTree::kInvalidNodeId)
     tree->property_trees()->transform_tree.OnTransformAnimated(
         transform, transform_id, tree);
   LayerImpl* layer = tree->LayerById(layer_id);
   if (layer)
     layer->set_was_ever_ready_since_last_transform_animation(false);
 }
 
 void LayerTreeHostImpl::SetTreeLayerScrollOffsetMutated(
     ElementId element_id,
     LayerTreeImpl* tree,
     const gfx::ScrollOffset& scroll_offset) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerByElementId(element_id);
-  if (layer) {
-    layer->OnScrollOffsetAnimated(scroll_offset);
+  const int layer_id = tree->LayerIdByElementId(element_id);
+  DCHECK(tree->property_trees()->IsInIdToIndexMap(
+      PropertyTrees::TreeType::TRANSFORM, layer_id));
+  DCHECK(tree->property_trees()->IsInIdToIndexMap(
+      PropertyTrees::TreeType::SCROLL, layer_id));
+  const int transform_id =
+      tree->property_trees()->transform_id_to_index_map[layer_id];
+  const int scroll_id =
+      tree->property_trees()->scroll_id_to_index_map[layer_id];
+  if (transform_id != TransformTree::kInvalidNodeId &&
+      scroll_id != ScrollTree::kInvalidNodeId) {
+    tree->property_trees()->scroll_tree.OnScrollOffsetAnimated(
+        layer_id, transform_id, scroll_id, scroll_offset, tree);
     // Run mutation callbacks to respond to updated scroll offset.
     Mutate(CurrentBeginFrameArgs().frame_time);
   }
 }
 
 bool LayerTreeHostImpl::AnimationsPreserveAxisAlignment(
     const LayerImpl* layer) const {
   return animation_host_->AnimationsPreserveAxisAlignment(layer->element_id());
 }
 
@@ skipping 192 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc