cc: Stop cache transform invertibility at Layer and LayerImpl

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 88 matching lines @@
         data.num_layer_or_descendants_with_touch_handler;
     num_unclipped_descendants += data.num_unclipped_descendants;
     num_descendants_that_draw_content += data.num_descendants_that_draw_content;
   }
 };
 
 static inline bool IsRootLayer(const Layer* layer) {
   return !layer->parent();
 }
 
-static bool HasInvertibleOrAnimatedTransform(Layer* layer) {
-  return layer->transform_is_invertible() ||
-         layer->HasPotentiallyRunningTransformAnimation();
-}
-
-static bool HasInvertibleOrAnimatedTransformForTesting(LayerImpl* layer) {
-  return layer->transform().IsInvertible() ||
-         layer->HasPotentiallyRunningTransformAnimation();
-}
-
 static bool IsMetaInformationRecomputationNeeded(Layer* layer) {
   return layer->layer_tree_host()->needs_meta_info_recomputation();
 }
 
 // Recursively walks the layer tree(if needed) to compute any information
 // that is needed before doing the main recursion.
 static void PreCalculateMetaInformationInternal(
     Layer* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
   if (!IsMetaInformationRecomputationNeeded(layer)) {
     DCHECK(IsRootLayer(layer));
     return;
   }
 
   if (layer->clip_parent())
     recursive_data->num_unclipped_descendants++;
 
-  if (!HasInvertibleOrAnimatedTransform(layer)) {
-    // Layers with singular transforms should not be drawn, the whole subtree
-    // can be skipped.
-    return;
-  }
-
   for (size_t i = 0; i < layer->children().size(); ++i) {
     Layer* child_layer = layer->child_at(i);
 
     PreCalculateMetaInformationRecursiveData data_for_child;
     PreCalculateMetaInformationInternal(child_layer, &data_for_child);
     recursive_data->Merge(data_for_child);
   }
 
   if (layer->clip_children()) {
     size_t num_clip_children = layer->clip_children()->size();
@@ skipping 13 matching lines @@
   if (IsRootLayer(layer))
     layer->layer_tree_host()->SetNeedsMetaInfoRecomputation(false);
 }
 
 static void PreCalculateMetaInformationInternalForTesting(
     LayerImpl* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
   if (layer->test_properties()->clip_parent)
     recursive_data->num_unclipped_descendants++;
 
-  if (!HasInvertibleOrAnimatedTransformForTesting(layer)) {
-    // Layers with singular transforms should not be drawn, the whole subtree
-    // can be skipped.
-    return;
-  }
-
   for (size_t i = 0; i < layer->children().size(); ++i) {
     LayerImpl* child_layer = layer->child_at(i);
 
     PreCalculateMetaInformationRecursiveData data_for_child;
     PreCalculateMetaInformationInternalForTesting(child_layer, &data_for_child);
     recursive_data->Merge(data_for_child);
   }
 
   if (layer->test_properties()->clip_children) {
     size_t num_clip_children = layer->test_properties()->clip_children->size();
@@ skipping 1075 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc