Stop displaying layers with non-invertible transforms.

cc/trees/layer_tree_host_common_unittest.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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 2924 matching lines @@
                                gfx::PointF(5.f, 5.f),
                                gfx::Size(50, 50),
                                true,
                                false);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
+  // TODO(avallee): Cases 2, 3 comments no longer accurate. CSS spec days to

[ajuma, 2014/04/16 19:24:49]

Please fix the comments rather than having this TODO.

[avallee, 2014/04/16 19:33:25]

Done.

+  // never draw objects with uninvertible transforms.
+
   // Case 2: a matrix with flattened z, technically uninvertible but still
   // drawable and visible. In this case, we must assume that the entire layer
   // bounds are visible since there is no way to inverse-project the surface
   // bounds to intersect.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(child.get(),
                                uninvertible_matrix,
                                gfx::PointF(),
                                gfx::PointF(5.f, 5.f),
                                gfx::Size(50, 50),
                                true,
                                false);
 
   ExecuteCalculateDrawProperties(root.get());
 
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), child->visible_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(5, 5, 50, 50), child->drawable_content_rect());
+  EXPECT_TRUE(child->visible_content_rect().IsEmpty());
+  EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 3: a matrix with flattened z, technically uninvertible but still
   // drawable, but not visible. In this case, we don't need to conservatively
   // assume that the whole layer is visible.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.Translate(500.0, 0.0);
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(child.get(),
                                uninvertible_matrix,
                                gfx::PointF(),
                                gfx::PointF(5.f, 5.f),
                                gfx::Size(50, 50),
                                true,
                                false);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
-  EXPECT_RECT_EQ(gfx::Rect(505, 5, 50, 50), child->drawable_content_rect());
+  EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 6135 matching lines @@
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
+TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
+  scoped_refptr<LayerWithForcedDrawsContent> root =
+      make_scoped_refptr(new LayerWithForcedDrawsContent);
+  scoped_refptr<LayerWithForcedDrawsContent> parent =
+      make_scoped_refptr(new LayerWithForcedDrawsContent);
+  scoped_refptr<LayerWithForcedDrawsContent> child =
+      make_scoped_refptr(new LayerWithForcedDrawsContent);
+
+  root->AddChild(parent);
+  parent->AddChild(child);
+
+  gfx::Transform identity_transform;
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_transform,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(50, 50),
+                               true,
+                               true);
+  root->SetForceRenderSurface(true);
+  SetLayerPropertiesForTesting(parent.get(),
+                               identity_transform,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(30, 30),
+                               true,
+                               true);
+  parent->SetForceRenderSurface(true);
+  SetLayerPropertiesForTesting(child.get(),
+                               identity_transform,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(20, 20),
+                               true,
+                               true);
+  child->SetForceRenderSurface(true);
+
+  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  host->SetRootLayer(root);
+
+  ExecuteCalculateDrawProperties(root.get());
+
+  EXPECT_EQ(3u, render_surface_layer_list()->size());
+
+  gfx::Transform singular_transform;
+  singular_transform.Scale3d(
+      SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
+
+  child->SetTransform(singular_transform);
+
+  ExecuteCalculateDrawProperties(root.get());
+
+  EXPECT_EQ(2u, render_surface_layer_list()->size());
+
+  // Ensure that the entire subtree under a layer with singular transform does
+  // not get rendered.
+  parent->SetTransform(singular_transform);
+  child->SetTransform(identity_transform);
+
+  ExecuteCalculateDrawProperties(root.get());
+
+  EXPECT_EQ(1u, render_surface_layer_list()->size());
+}
+
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //
@@ skipping 849 matching lines @@
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
 }
 
 }  // namespace
 }  // namespace cc