Stop displaying layers with non-invertible transforms.

cc/trees/layer_tree_host_common.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_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 460 matching lines @@
   bool can_accept_input = !layer->touch_event_handler_region().IsEmpty() ||
       layer->have_wheel_event_handlers();
   if (!layer->DrawsContent() && !can_accept_input)
     return true;
 
   return false;
 }
 
 static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
                                           bool layer_is_drawn) {
+  // If the layer transform is not invertible, it should not be drawn.
+  if (!layer->transform_is_invertible())

[ajuma, 2014/03/28 18:49:07]

Can this early-out interact negatively with readback requests (see the next
check below)? Should we also check if transform is animating here (just as we do
below before checking for opacity 0)?

[avallee, 2014/04/15 18:53:25]

Yes, we do. The spec is all about requiring that it's not rendered. It shouldn't
show up in readback or at any singular in-between transform.

[ajuma, 2014/04/15 19:45:10]

I agree with not drawing it, but I'm worried that if we just skip the layer here
altogether even when we're animating it, this will make it impossible to solve
issues like crbug.com/354880, where we want to pre-rasterize layers that are
animating scale from 0 (since we'll end up skipping the subtree that we want to
pre-rasterize). Can we prevent drawing such an animated layer without skipping
it here?

[avallee, 2014/04/16 18:20:56]

Done. Won't skip on animated transform. Fix for second CL.

+    return true;
+
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // If the layer is not drawn, then skip it and its subtree.
   if (!layer_is_drawn)
     return true;
 
   // If layer is on the pending tree and opacity is being animated then
   // this subtree can't be skipped as we need to create, prioritize and
   // include tiles for this layer when deciding if tree can be activated.
   if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating())
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
   // entire subtree can be skipped if this layer is fully transparent.
   // TODO(sad): Don't skip layers used for hit testing crbug.com/295295.
   return !layer->opacity();
 }
 
 static inline bool SubtreeShouldBeSkipped(Layer* layer, bool layer_is_drawn) {
+  // If the layer transform is not invertible, it should not be drawn.
+  if (!layer->transform_is_invertible())

[ajuma, 2014/03/28 18:49:07]

Same questions as above about readback and animating transforms.

[avallee, 2014/04/15 18:53:25]

See above.

+    return true;
+
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // If the layer is not drawn, then skip it and its subtree.
   if (!layer_is_drawn)
     return true;
 
   // If the opacity is being animated then the opacity on the main thread is
@@ skipping 549 matching lines @@
 
 // Recursively walks the layer tree to compute any information that is needed
 // before doing the main recursion.
 template <typename LayerType>
 static void PreCalculateMetaInformation(
     LayerType* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
   bool has_delegated_content = layer->HasDelegatedContent();
   int num_descendants_that_draw_content = 0;
 
+  if (!layer->transform_is_invertible()) {

[ajuma, 2014/03/28 18:49:07]

Should we check if transform is animating? (e.g. Suppose we're animating scale
from 0 to 1. Do we really want to skip this layer when this is run on the main
thread layer tree?)

[avallee, 2014/04/15 18:53:25]

Yes we do.

[ajuma, 2014/04/15 19:45:10]

We do want to skip, or we do check? (I don't see this checked in the latest
patch.)

[avallee, 2014/04/16 18:20:56]

Let's check for now and this will need to be changed for pre-rastering.

+    // Layers with singular transforms should not be drawn, the whole subtree
+    // can be skipped.
+    return;
+  }
+
   if (has_delegated_content) {
     // Layers with delegated content need to be treated as if they have as
     // many children as the number of layers they own delegated quads for.
     // Since we don't know this number right now, we choose one that acts like
     // infinity for our purposes.
     num_descendants_that_draw_content = 1000;
   }
 
   layer->draw_properties().sorted_for_recursion = false;
   layer->draw_properties().has_child_with_a_scroll_parent = false;
@@ skipping 1314 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc