cc : Workaround for null layer impls and invalid property tree indices

cc/trees/draw_property_utils.cc

 // 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.
 
 #include "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 440 matching lines @@
 
 template <typename LayerType>
 static inline bool LayerShouldBeSkippedInternal(
     LayerType* layer,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree) {
   const TransformNode* transform_node =
       transform_tree.Node(layer->transform_tree_index());
   const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index());
 
+  DCHECK(effect_node);
+  DCHECK(transform_node);
+  // TODO(crbug.com/726423) : This is a workaround for crbug.com/726225 to
+  // avoid crashing when there is no effect or transform node. Effect node and
+  // transform node should always exist here and this workaround should be
+  // removed.
+  if (!transform_node || !effect_node)
+    return true;
+
   if (effect_node->has_render_surface &&
       effect_node->num_copy_requests_in_subtree > 0)
     return false;
+
   // If the layer transform is not invertible, it should be skipped.
   // TODO(ajuma): Correctly process subtrees with singular transform for the
   // case where we may animate to a non-singular transform and wish to
   // pre-raster.
   return !transform_node->node_and_ancestors_are_animated_or_invertible ||
          effect_node->hidden_by_backface_visibility || !effect_node->is_drawn;
 }
 
 template <typename LayerType>
 static void UpdateElasticOverscrollInternal(
@@ skipping 370 matching lines @@
   }
 }
 
 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
                                const PropertyTrees* property_trees,
                                std::vector<LayerImpl*>* visible_layer_list) {
   const TransformTree& transform_tree = property_trees->transform_tree;
   const EffectTree& effect_tree = property_trees->effect_tree;
 
   for (auto* layer_impl : *layer_tree_impl) {
+    DCHECK(layer_impl);
+    DCHECK(layer_impl->layer_tree_impl());
+    // TODO(crbug.com/726423) : This is a workaround for crbug.com/725851 to
+    // avoid crashing when layer_impl is nullptr. This workaround should be
+    // removed as layer_impl should not be nullptr here.
+    if (!layer_impl)
+      continue;
     if (!IsRootLayer(layer_impl) &&
         LayerShouldBeSkipped(layer_impl, transform_tree, effect_tree))
       continue;
 
     bool layer_is_drawn =
         effect_tree.Node(layer_impl->effect_tree_index())->is_drawn;
 
     if (LayerNeedsUpdate(layer_impl, layer_is_drawn, property_trees))
       visible_layer_list->push_back(layer_impl);
   }
@@ skipping 232 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc