SubtreeShouldBeSkipped uses information from property trees

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 <stddef.h>
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
+#include "cc/animation/animation_player.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
@@ skipping 3489 matching lines @@
                                gfx::PointF(10.f, 10.f), gfx::Size(100, 100),
                                false, true, false);
   SetLayerPropertiesForTesting(grand_child, rotation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
-  EXPECT_FALSE(grand_child->DrawTransform().IsInvertible());
+  EXPECT_FALSE(root->layer_tree_impl()
+                   ->property_trees()
+                   ->transform_tree.Node(grand_child->transform_tree_index())
+                   ->data.ancestors_are_invertible);
 
-  // CalcDrawProps only skips a subtree when a layer's own transform is
-  // uninvertible, not when its draw transform is invertible, since CDP makes
-  // skipping decisions before computing a layer's draw transform. Property
-  // trees make skipping decisions after computing draw transforms, so could be
-  // made to skip layers with an uninvertible draw transform (once CDP is
-  // deleted).
-  EXPECT_EQ(gfx::Rect(grand_child->bounds()),
-            grand_child->visible_layer_rect());
+  // CalcDrawProps skips a subtree when a layer's screen space transform is
+  // uninvertible
+  EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        OcclusionForLayerWithUninvertibleDrawTransform) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_ptr<OutputSurface> output_surface = FakeOutputSurface::Create3d();
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
@@ skipping 38 matching lines @@
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr =
       host_impl.active_tree()->root_layer()->children()[0]->children()[0];
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
-  EXPECT_FALSE(grand_child_ptr->DrawTransform().IsInvertible());
+  EXPECT_FALSE(
+      host_impl.active_tree()
+          ->property_trees()
+          ->transform_tree.Node(grand_child_ptr->transform_tree_index())
+          ->data.ancestors_are_invertible);
 
-  // Since |grand_child| has an uninvertible draw transform, it is treated as
-  // unoccluded (even though |occluding_child| comes later in draw order, and
-  // hence potentially occludes it).
-  gfx::Rect layer_bounds = gfx::Rect(grand_child_ptr->bounds());
+  // Since |grand_child| has an univertible draw transform, it is skipped so

[ajuma, 2016/03/31 19:22:32]

uninvertible (missing 'n')
Also, replace "draw transform" with "screen space transform"

[sunxd, 2016/04/01 17:57:45]

Done.

+  // that we are not computing its occlusion_in_content_space.
+  gfx::Rect layer_bounds = gfx::Rect();
   EXPECT_EQ(
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularTransformDoesNotPreventClearingDrawProperties) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
@@ skipping 2234 matching lines @@
 
   std::vector<scoped_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   copy_layer->AddChild(std::move(copy_child));
   copy_parent->AddChild(std::move(copy_layer));
   root->AddChild(std::move(copy_parent));
-  host_impl.pending_tree()->SetRootLayer(std::move(root));
-  LayerImpl* root_ptr = host_impl.pending_tree()->root_layer();
 
   LayerImplList render_surface_layer_list;
-  root_ptr->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
+  LayerImpl* root_layer = root.get();
+  root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_ptr, root_ptr->bounds(), &render_surface_layer_list,
-      root_ptr->layer_tree_impl()->current_render_surface_list_id());
+      root_layer, root_layer->bounds(), &render_surface_layer_list,
+      root_layer->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_layer_list.size());
-  EXPECT_EQ(root_ptr->id(), render_surface_layer_list.at(0)->id());
+  EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 2 contributing layer, since the
   // other layers are empty/clipped away.
-  ASSERT_EQ(2u, root_ptr->render_surface()->layer_list().size());
-  EXPECT_EQ(root_ptr->id(),
-            root_ptr->render_surface()->layer_list().at(0)->id());
+  ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());
+  EXPECT_EQ(root_layer->id(),
+            root_layer->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
@@ skipping 526 matching lines @@
   SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, false);
   child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
   child2->AddChild(std::move(child3));
   child1->AddChild(std::move(child2));
   root->AddChild(std::move(child1));
-  host_impl.active_tree()->SetRootLayer(std::move(root));
-  LayerImpl* root_ptr = host_impl.active_tree()->root_layer();
+  LayerImpl* root_layer = root.get();
+  root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
 
   {
     LayerImplList render_surface_layer_list;
-    FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root_ptr);
-    root_ptr->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
+    FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root_layer);
+    root_layer->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_ptr, root_ptr->bounds(), &render_surface_layer_list,
-        root_ptr->layer_tree_impl()->current_render_surface_list_id());
+        root_layer, root_layer->bounds(), &render_surface_layer_list,
+        root_layer->layer_tree_impl()->current_render_surface_list_id());
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     LayerIterator end = LayerIterator::End(&render_surface_layer_list);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
          it != end; ++it) {
       if (it.represents_target_render_surface())
         count_represents_target_render_surface++;
       if (it.represents_contributing_render_surface())
         count_represents_contributing_render_surface++;
       if (it.represents_itself())
         count_represents_itself++;
     }
 
     // Two render surfaces.
     EXPECT_EQ(2, count_represents_target_render_surface);
     // Second render surface contributes to root render surface.
     EXPECT_EQ(1, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 
   {
     LayerImplList render_surface_layer_list;
-    root_ptr->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
+    root_layer->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_ptr, root_ptr->bounds(), &render_surface_layer_list,
-        root_ptr->layer_tree_impl()->current_render_surface_list_id());
+        root_layer, root_layer->bounds(), &render_surface_layer_list,
+        root_layer->layer_tree_impl()->current_render_surface_list_id());
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(1u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     LayerIterator end = LayerIterator::End(&render_surface_layer_list);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
@@ skipping 309 matching lines @@
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 
   child->SetTransform(singular_transform);
 
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   // Ensure that the entire subtree under a layer with singular transform does
   // not get rendered.
   parent->SetTransform(singular_transform);
   child->SetTransform(identity_transform);
 
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
@@ skipping 535 matching lines @@
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
 
   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_parent_raw = grand_parent.get();
 
   child->AddChild(std::move(grand_child));
   parent->AddChild(std::move(child));
   grand_parent->AddChild(std::move(parent));
-  host_impl.active_tree()->SetRootLayer(std::move(grand_parent));
 
   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
+  host_impl.active_tree()->SetRootLayer(std::move(grand_parent));
+
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // No layers have animations.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
@@ skipping 1498 matching lines @@
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   AddAnimationToLayerWithExistingPlayer(child->id(), timeline(),
                                         std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect());
 }
 
-TEST_F(LayerTreeHostCommonTest, SkippingSubtreeImpl) {
+TEST_F(LayerTreeHostCommonTest, SkippingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   gfx::Transform identity;
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.active_tree(), 2);
   scoped_ptr<LayerImpl> grandchild =
@@ skipping 18 matching lines @@
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->AddChild(std::move(grandchild));
   root->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   // Check the non-skipped case.
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
-  EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+  // ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  // EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
+
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
+  // This line is used to make the results of skipping and not skipping layers
+  // different.
+  singular.matrix().set(0, 1, 1);
+
+  gfx::Transform rotate;
+  rotate.Rotate(90);
+
+  gfx::Transform rotate_back_and_translate;
+  rotate_back_and_translate.RotateAboutYAxis(180);
+  rotate_back_and_translate.Translate(-10, 0);
 
   child_ptr->SetTransform(singular);
+  host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->SetTransform(identity);
 
   child_ptr->SetHideLayerAndSubtree(true);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->SetHideLayerAndSubtree(false);
 
   child_ptr->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
+  child_ptr->SetOpacity(1.f);
 
+  root_ptr->SetTransform(singular);
+  // Force transform tree to have a node for child, so that ancestor's
+  // invertible transform can be tested.
+  child_ptr->SetTransform(rotate);
+  host_impl.active_tree()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
+  root_ptr->SetTransform(identity);
+  child_ptr->SetTransform(identity);
+
+  root_ptr->SetOpacity(0.f);
+  child_ptr->SetOpacity(0.7f);
+  host_impl.active_tree()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
+  root_ptr->SetOpacity(1.f);
+
+  child_ptr->SetOpacity(0.f);
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   std::vector<scoped_ptr<CopyOutputRequest>> requests;
   requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
   grandchild_ptr->PassCopyRequests(&requests);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+  requests.clear();
+  grandchild_ptr->PassCopyRequests(&requests);
+  child_ptr->SetOpacity(1.f);
+
+  // A double sided render surface with backface visible should not be skipped
+  grandchild_ptr->set_visible_layer_rect(gfx::Rect());
+  child_ptr->SetHasRenderSurface(true);
+  child_ptr->SetDoubleSided(true);
+  child_ptr->SetTransform(rotate_back_and_translate);
+  root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+  child_ptr->ClearRenderSurfaceLayerList();

[ajuma, 2016/03/31 19:22:33]

Is this line needed? We don't normally call this directly from tests.

[sunxd, 2016/04/01 17:57:45]

Hmm, the test can still pass without this line. I thought we should clear
everything we add in each cycle so that the next tests can succeed.

+  child_ptr->SetTransform(identity);
+
+  scoped_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  TransformOperations start;
+  start.AppendTranslate(1.f, 2.f, 3.f);
+  gfx::Transform transform;
+  transform.Scale3d(1.0, 2.0, 3.0);
+  TransformOperations operation;
+  operation.AppendMatrix(transform);
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
+  scoped_ptr<Animation> transform_animation(
+      Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
+  scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
+  host_impl.active_tree()->animation_host()->RegisterPlayerForLayer(
+      root_ptr->id(), player.get());
+  host_impl.active_tree()
+      ->animation_host()
+      ->GetControllerForLayerId(root_ptr->id())
+      ->AddAnimation(std::move(transform_animation));
+  grandchild_ptr->set_visible_layer_rect(gfx::Rect());
+  child_ptr->SetScrollClipLayer(root_ptr->id());
+  root_ptr->SetTransform(singular);
+  child_ptr->SetTransform(singular);
+  root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+
+  host_impl.active_tree()->animation_host()->UnregisterPlayerForLayer(
+      root_ptr->id(), player.get());
+}
+
+TEST_F(LayerTreeHostCommonTest, SkippingPendingLayerImpl) {
+  FakeImplTaskRunnerProvider task_runner_provider;
+  TestSharedBitmapManager shared_bitmap_manager;
+  TestTaskGraphRunner task_graph_runner;
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
+                                  &task_graph_runner);
+
+  gfx::Transform identity;
+  host_impl.CreatePendingTree();
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
+  scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
+  scoped_ptr<LayerImpl> grandchild =
+      LayerImpl::Create(host_impl.pending_tree(), 3);
+
+  scoped_ptr<FakePictureLayerImpl> greatgrandchild(
+      FakePictureLayerImpl::Create(host_impl.pending_tree(), 4));
+
+  child->SetDrawsContent(true);
+  grandchild->SetDrawsContent(true);
+  greatgrandchild->SetDrawsContent(true);
+
+  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(100, 100), true, false,
+                               true);
+  SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               false);
+  SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               false);
+
+  LayerImpl* root_ptr = root.get();
+  LayerImpl* grandchild_ptr = grandchild.get();
+
+  child->AddChild(std::move(grandchild));
+  root->AddChild(std::move(child));
+
+  host_impl.pending_tree()->SetRootLayer(std::move(root));
+
+  // Check the non-skipped case.
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  scoped_ptr<TimingFunction> func = EaseTimingFunction::Create();
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta(), 0.9f, std::move(func)));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 0.3f, nullptr));
+  scoped_ptr<Animation> animation(
+      Animation::Create(std::move(curve), 3, 3, TargetProperty::OPACITY));
+  scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
+  host_impl.active_tree()->animation_host()->RegisterPlayerForLayer(
+      root_ptr->id(), player.get());
+  host_impl.active_tree()
+      ->animation_host()
+      ->GetControllerForLayerId(root_ptr->id())
+      ->AddAnimation(std::move(animation));
+  root_ptr->SetOpacity(0);
+  grandchild_ptr->set_visible_layer_rect(gfx::Rect());
+  root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
+
+  host_impl.active_tree()->animation_host()->UnregisterPlayerForLayer(
+      root_ptr->id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
   scoped_refptr<Layer> root = Layer::Create();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
@@ skipping 767 matching lines @@
                                true);
   SetLayerPropertiesForTesting(render_surface1, large_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
 
   ExecuteCalculateDrawProperties(root);
 
-  bool is_inf_or_nan =
-      std::isinf(
-          render_surface2->render_surface()->draw_transform().matrix().get(
-              0, 0)) ||
-      std::isnan(
-          render_surface2->render_surface()->draw_transform().matrix().get(0,
-                                                                           0));
-  EXPECT_TRUE(is_inf_or_nan);
-  is_inf_or_nan =
-      std::isinf(
-          render_surface2->render_surface()->draw_transform().matrix().get(
-              1, 1)) ||
-      std::isnan(
-          render_surface2->render_surface()->draw_transform().matrix().get(1,
-                                                                           1));
-  EXPECT_TRUE(is_inf_or_nan);
+  // render_surface2 is skipped because of singular transform
+  EXPECT_EQ(identity_matrix,

[jaydasika, 2016/03/31 18:32:56]

Why was it not skipped before this CL ? In any case, can you change the
transform to a large non-singular transform so that that large transform case
remains tested ?

[sunxd, 2016/04/01 17:57:45]

None of the transforms of the layer and its ancestors are singular, but because
of float math, their combination is singular. Thus logically, the layer should
be skipped.

I will check that to make it test correctly.

[jaydasika, 2016/04/01 19:10:11]

That's weird because only one layer has non-identity transform. But, this test
is unrelated to this CL, so feel free to land this and sort it out in a follow
up or leave a TODO for me and I will sort it out later.  

+            render_surface2->render_surface()->draw_transform());
   EXPECT_EQ(gfx::RectF(),
             render_surface2->render_surface()->DrawableContentRect());
 
   std::vector<LayerImpl*>* rsll = render_surface_layer_list_impl();
   bool root_in_rsll =
       std::find(rsll->begin(), rsll->end(), root) != rsll->end();
   EXPECT_TRUE(root_in_rsll);
   bool render_surface2_in_rsll =
       std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end();
   EXPECT_FALSE(render_surface2_in_rsll);
@@ skipping 224 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc