Track transform animation content readiness on TransformNode.

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 925 matching lines @@
           append_quads_data.checkerboarded_no_recording_content_area);
       rendering_stats_instrumentation_->AddCheckerboardedNeedsRasterContentArea(
           append_quads_data.checkerboarded_needs_raster_content_area);
 
       num_missing_tiles += append_quads_data.num_missing_tiles;
       num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
       checkerboarded_no_recording_content_area +=
           append_quads_data.checkerboarded_no_recording_content_area;
       checkerboarded_needs_raster_content_area +=
           append_quads_data.checkerboarded_needs_raster_content_area;
+      TransformNode* transform_node =
+          active_tree()->property_trees()->transform_tree.Node(
+              layer->transform_tree_index());

[wkorman, 2017/05/20 01:31:27]

Are we assured that we will always have a transform node, or do we need to check
for TransformTree::kInvalidNodeId?

[pdr., 2017/05/22 17:03:34]

We've had a bunch of crashes in this area recently (crbug.com/712298,
crbug.com/708951, crbug.com/721772). That said, I think we should not guard
against this in new code, especially now that we better understand this area.
LGTM for leaving this as-is without checking for a transform node.

       if (append_quads_data.num_missing_tiles > 0) {
         have_missing_animated_tiles |=
-            !layer->was_ever_ready_since_last_transform_animation() ||
+            !transform_node->ready_since_animation ||
             layer->screen_space_transform_is_animating();
       } else {
-        layer->set_was_ever_ready_since_last_transform_animation(true);
+        transform_node->ready_since_animation = true;

[jaydasika, 2017/05/22 18:11:29]

As layer->transform node is not 1:1, you can't do this here. The value of
ready_since_animation with this logic would depend on the num_missing_tiles
value of the last layer referencing that transform node (this function iterates
through all drawn layers). So, we need to have this on layers.

Since the aim here is to remove layer references from
LayerTreeImpl::SetTransformMutated, we could have a field for this on both
transform node and layer. So, you would update the field on transform node in
LayerTreeImpl::SetTransformMutated and the field on layer here and the actual
value of ready_since_animation would be inferred from both (this would be
similar to how we do damage tracking where we have both
LayerImpl::layer_property_changed and TransformNode::transform_changed).

       }
     }
     frame->activation_dependencies.insert(
         frame->activation_dependencies.end(),
         append_quads_data.activation_dependencies.begin(),
         append_quads_data.activation_dependencies.end());
   }
 
   // If CommitToActiveTree() is true, then we wait to draw until
   // NotifyReadyToDraw. That means we're in as good shape as is possible now,
@@ skipping 3266 matching lines @@
             transform_node->is_currently_animating =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             transform_node->has_potential_animation =
                 state.potentially_animating[property];
             transform_node->has_only_translation_animations =
                 mutator_host()->HasOnlyTranslationTransforms(element_id,
                                                              list_type);
             property_trees->transform_tree.set_needs_update(true);
             tree->set_needs_update_draw_properties();
-            // TODO(crbug.com/702777):
-            // was_ever_ready_since_last_transform_animation should not live on
-            // layers.
-            if (LayerImpl* layer = tree->LayerByElementId(element_id)) {
-              layer->set_was_ever_ready_since_last_transform_animation(false);
-            }
+            transform_node->ready_since_animation = false;
           }
         }
         break;
       case TargetProperty::OPACITY:
         if (EffectNode* effect_node =
                 property_trees->effect_tree.FindNodeFromElementId(element_id)) {
           if (mask.currently_running[property])
             effect_node->is_currently_animating_opacity =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
@@ skipping 94 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc