Get rid of two callsites of effect_tree.FindNodeIndexFromOwningLayerId.

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 <memory>
@@ skipping 860 matching lines @@
   grand_child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
   grand_child_of_rs2->test_properties()->transform = layer_transform;
   grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
 
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(GetRenderSurface(root));
-  ASSERT_FALSE(GetRenderSurface(child_of_root));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_root));
+  ASSERT_EQ(GetRenderSurface(child_of_root), GetRenderSurface(root));

[wkorman, 2017/05/11 22:09:26]

Adding assert/expect helper to shorten all of these refs seems worthwhile.

Or a RenderSurfacesEqual(a, b) and then use false/true assert/expects.

[chrishtr, 2017/05/11 22:15:39]

Per offline discussion, will just leave it.

+  ASSERT_EQ(GetRenderSurface(grand_child_of_root), GetRenderSurface(root));
 
-  ASSERT_TRUE(GetRenderSurface(render_surface1));
-  ASSERT_FALSE(GetRenderSurface(child_of_rs1));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs1));
+  ASSERT_NE(GetRenderSurface(render_surface1), GetRenderSurface(root));
+  ASSERT_EQ(GetRenderSurface(child_of_rs1), GetRenderSurface(render_surface1));
+  ASSERT_EQ(GetRenderSurface(grand_child_of_rs1),
+            GetRenderSurface(render_surface1));
 
-  ASSERT_TRUE(GetRenderSurface(render_surface2));
-  ASSERT_FALSE(GetRenderSurface(child_of_rs2));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs2));
+  ASSERT_NE(GetRenderSurface(render_surface2), GetRenderSurface(root));
+  ASSERT_NE(GetRenderSurface(render_surface2),
+            GetRenderSurface(render_surface1));
+  ASSERT_EQ(GetRenderSurface(child_of_rs2), GetRenderSurface(render_surface2));
+  ASSERT_EQ(GetRenderSurface(grand_child_of_rs2),
+            GetRenderSurface(render_surface2));
 
   // Verify all render target accessors
   EXPECT_EQ(GetRenderSurface(root), parent->render_target());
   EXPECT_EQ(GetRenderSurface(root), child_of_root->render_target());
   EXPECT_EQ(GetRenderSurface(root), grand_child_of_root->render_target());
 
   EXPECT_EQ(GetRenderSurface(render_surface1),
             render_surface1->render_target());
   EXPECT_EQ(GetRenderSurface(render_surface1), child_of_rs1->render_target());
   EXPECT_EQ(GetRenderSurface(render_surface1),
@@ skipping 640 matching lines @@
   surface1->test_properties()->force_render_surface = true;
   not_surface->SetBounds(gfx::Size(10, 10));
   not_surface->test_properties()->opacity = 0.5f;
   surface2->SetBounds(gfx::Size(10, 10));
   surface2->SetDrawsContent(true);
   surface2->test_properties()->opacity = 0.5f;
   surface2->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(GetRenderSurface(surface1));
-  ASSERT_FALSE(GetRenderSurface(not_surface));
+  ASSERT_EQ(GetRenderSurface(not_surface), GetRenderSurface(surface1));
   ASSERT_TRUE(GetRenderSurface(surface2));
   EXPECT_EQ(0.5f, GetRenderSurface(surface1)->draw_opacity());
   // surface2's draw opacity should include the opacity of not-surface and
   // itself, but not the opacity of surface1.
   EXPECT_EQ(0.25f, GetRenderSurface(surface2)->draw_opacity());
 }
 
 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   root->SetBounds(gfx::Size(10, 10));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   {
     ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(GetRenderSurface(root));
-    EXPECT_TRUE(GetRenderSurface(render_surface1));
+    EXPECT_NE(GetRenderSurface(render_surface1), GetRenderSurface(root));
   }
 
   {
     render_surface1->test_properties()->force_render_surface = false;
     render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
     ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
     EXPECT_TRUE(GetRenderSurface(root));
-    EXPECT_FALSE(GetRenderSurface(render_surface1));
+    EXPECT_EQ(GetRenderSurface(render_surface1), GetRenderSurface(root));
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   root->SetBounds(gfx::Size(100, 100));
   parent->test_properties()->transform = rotation_about_y_axis;
   parent->SetBounds(gfx::Size(10, 10));
   parent->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(GetRenderSurface(parent));
-  EXPECT_FALSE(GetRenderSurface(child));
-  EXPECT_FALSE(GetRenderSurface(grand_child));
+  EXPECT_EQ(GetRenderSurface(child), GetRenderSurface(parent));
+  EXPECT_EQ(GetRenderSurface(grand_child), GetRenderSurface(parent));
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->DrawTransform());
 
   // The screen-space transform inherited by |child| and |grand_child| should
   // have been flattened at their render target. In particular, the fact that
   // |grand_child| happens to preserve 3d shouldn't affect this flattening.
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
@@ skipping 417 matching lines @@
                                           timeline_impl(), 10.0, 30, 0);
   AddAnimatedTransformToElementWithPlayer(grand_child_of_rs2->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(GetRenderSurface(root));
-  ASSERT_FALSE(GetRenderSurface(child_of_root));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_root));
+  ASSERT_EQ(GetRenderSurface(child_of_root), GetRenderSurface(root));
+  ASSERT_EQ(GetRenderSurface(grand_child_of_root), GetRenderSurface(root));
 
-  ASSERT_TRUE(GetRenderSurface(render_surface1));
-  ASSERT_FALSE(GetRenderSurface(child_of_rs1));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs1));
+  ASSERT_NE(GetRenderSurface(render_surface1), GetRenderSurface(root));
+  ASSERT_EQ(GetRenderSurface(child_of_rs1), GetRenderSurface(render_surface1));
+  ASSERT_EQ(GetRenderSurface(grand_child_of_rs1),
+            GetRenderSurface(render_surface1));
 
-  ASSERT_TRUE(GetRenderSurface(render_surface2));
-  ASSERT_FALSE(GetRenderSurface(child_of_rs2));
-  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs2));
+  ASSERT_NE(GetRenderSurface(render_surface2), GetRenderSurface(root));
+  ASSERT_NE(GetRenderSurface(render_surface2),
+            GetRenderSurface(render_surface1));
+  ASSERT_EQ(GetRenderSurface(child_of_rs2), GetRenderSurface(render_surface2));
+  ASSERT_EQ(GetRenderSurface(grand_child_of_rs2),
+            GetRenderSurface(render_surface2));
 
   // Verify all render target accessors
   EXPECT_EQ(GetRenderSurface(root), root->render_target());
   EXPECT_EQ(GetRenderSurface(root), child_of_root->render_target());
   EXPECT_EQ(GetRenderSurface(root), grand_child_of_root->render_target());
 
   EXPECT_EQ(GetRenderSurface(render_surface1),
             render_surface1->render_target());
   EXPECT_EQ(GetRenderSurface(render_surface1), child_of_rs1->render_target());
   EXPECT_EQ(GetRenderSurface(render_surface1),
@@ skipping 1610 matching lines @@
       backface_matrix;
   back_facing_child_of_back_facing_surface->test_properties()->transform =
       backface_matrix;
 
   // Note: No layers preserve 3d. According to current W3C CSS gfx::Transforms
   // spec, these layers should blindly use their own local transforms to
   // determine back-face culling.
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
-  EXPECT_FALSE(GetRenderSurface(front_facing_child));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child));
-  EXPECT_TRUE(GetRenderSurface(front_facing_surface));
-  EXPECT_TRUE(GetRenderSurface(back_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_front_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_front_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_back_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_back_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(back_facing_child), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(front_facing_surface), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(back_facing_surface), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(back_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child_of_front_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(back_facing_child_of_front_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child_of_back_facing_surface),
+            GetRenderSurface(back_facing_surface));
+  EXPECT_EQ(GetRenderSurface(back_facing_child_of_back_facing_surface),
+            GetRenderSurface(back_facing_surface));
 
   EXPECT_EQ(3u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
   // Verify the behavior of back-face culling when preserves-3d transform style
@@ skipping 80 matching lines @@
   back_facing_child_of_front_facing_surface->test_properties()
       ->sorting_context_id = 1;
   front_facing_child_of_back_facing_surface->test_properties()
       ->sorting_context_id = 1;
   back_facing_child_of_back_facing_surface->test_properties()
       ->sorting_context_id = 1;
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
-  EXPECT_FALSE(GetRenderSurface(front_facing_child));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child));
-  EXPECT_TRUE(GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(back_facing_child), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(front_facing_surface), GetRenderSurface(root));
   // We expect that a has_render_surface was created but not used.
-  EXPECT_TRUE(GetRenderSurface(back_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_front_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_front_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_back_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_back_facing_surface));
+  EXPECT_NE(GetRenderSurface(back_facing_surface), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(back_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child_of_front_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(back_facing_child_of_front_facing_surface),
+            GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(front_facing_child_of_back_facing_surface),
+            GetRenderSurface(back_facing_surface));
+  EXPECT_EQ(GetRenderSurface(back_facing_child_of_back_facing_surface),
+            GetRenderSurface(back_facing_surface));
 
   EXPECT_EQ(3u, update_layer_list_impl()->size());
 
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
@@ skipping 45 matching lines @@
   animating_surface->test_properties()->transform = backface_matrix;
   animating_surface->test_properties()->force_render_surface = true;
   child_of_animating_surface->SetBounds(gfx::Size(100, 100));
   child_of_animating_surface->test_properties()->transform = backface_matrix;
   animating_child->SetBounds(gfx::Size(100, 100));
   animating_child->test_properties()->transform = backface_matrix;
   child2->SetBounds(gfx::Size(100, 100));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
-  EXPECT_FALSE(GetRenderSurface(child));
+  EXPECT_EQ(GetRenderSurface(child), GetRenderSurface(root));
   EXPECT_TRUE(GetRenderSurface(animating_surface));
-  EXPECT_FALSE(GetRenderSurface(child_of_animating_surface));
-  EXPECT_FALSE(GetRenderSurface(animating_child));
-  EXPECT_FALSE(GetRenderSurface(child2));
+  EXPECT_EQ(GetRenderSurface(child_of_animating_surface),
+            GetRenderSurface(animating_surface));
+  EXPECT_EQ(GetRenderSurface(animating_child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(child2), GetRenderSurface(root));
 
   EXPECT_EQ(1u, update_layer_list_impl()->size());
 
   // The back facing layers are culled from the layer list, and have an empty
   // visible rect.
   EXPECT_TRUE(UpdateLayerListImplContains(child2->id()));
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(animating_surface->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child_of_animating_surface->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(animating_child->visible_layer_rect().IsEmpty());
@@ skipping 38 matching lines @@
 
   front_facing_surface->test_properties()->sorting_context_id = 1;
   back_facing_surface->test_properties()->sorting_context_id = 1;
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
   EXPECT_TRUE(GetRenderSurface(front_facing_surface));
 
   // We expect the render surface to have been created, but remain unused.
-  EXPECT_TRUE(GetRenderSurface(back_facing_surface));
-  EXPECT_FALSE(GetRenderSurface(child1));
-  EXPECT_FALSE(GetRenderSurface(child2));
+  EXPECT_NE(GetRenderSurface(back_facing_surface), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(child1), GetRenderSurface(front_facing_surface));
+  EXPECT_EQ(GetRenderSurface(child2), GetRenderSurface(back_facing_surface));
 
   EXPECT_EQ(2u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(child1->id()));
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
@@ skipping 379 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(10, 10));
   child->test_properties()->opacity = 0.5f;
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
-  EXPECT_FALSE(GetRenderSurface(child));
+  EXPECT_EQ(GetRenderSurface(child), GetRenderSurface(root));
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(host()->GetSettings(), &task_runner_provider,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
@@ skipping 1072 matching lines @@
   child2->SetBounds(bounds);
   child2->SetDrawsContent(true);
   child2->test_properties()->sorting_context_id = 1;
   child3->SetBounds(bounds);
   child3->SetDrawsContent(true);
   child3->test_properties()->sorting_context_id = 1;
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(GetRenderSurface(root));
-  EXPECT_FALSE(GetRenderSurface(child1));
-  EXPECT_TRUE(GetRenderSurface(child2));
-  EXPECT_FALSE(GetRenderSurface(child3));
+  EXPECT_EQ(GetRenderSurface(child1), GetRenderSurface(root));
+  EXPECT_NE(GetRenderSurface(child2), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(child3), GetRenderSurface(child2));
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
 
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface1);
 
   LayerImpl* flattener = AddChild<LayerImpl>(back_facing);
@@ skipping 2855 matching lines @@
   grandchild->SetBounds(gfx::Size(50, 50));
   grandchild->SetDrawsContent(true);
 
   SetElementIdsForTesting();
   AddOpacityTransitionToElementWithPlayer(child->element_id(), timeline_impl(),
                                           10.0, 1.f, 0.2f, false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1.f, child->Opacity());
   EXPECT_TRUE(GetRenderSurface(root));
-  EXPECT_TRUE(GetRenderSurface(child));
-  EXPECT_FALSE(GetRenderSurface(grandchild));
+  EXPECT_NE(GetRenderSurface(child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(grandchild), GetRenderSurface(child));
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(50, 50));
   child->SetBounds(gfx::Size(50, 50));
   grandchild->SetBounds(gfx::Size(50, 50));
 
   SetElementIdsForTesting();
   AddAnimatedFilterToElementWithPlayer(child->element_id(), timeline_impl(),
                                        10.0, 0.1f, 0.2f);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(GetRenderSurface(root));
-  EXPECT_TRUE(GetRenderSurface(child));
-  EXPECT_FALSE(GetRenderSurface(grandchild));
+  EXPECT_NE(GetRenderSurface(child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(grandchild), GetRenderSurface(child));
 
   EXPECT_TRUE(GetRenderSurface(root)->Filters().IsEmpty());
   EXPECT_TRUE(GetRenderSurface(child)->Filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // Verify that having a filter animation with a delayed start time creates a
@@ skipping 22 matching lines @@
   std::unique_ptr<Animation> animation =
       Animation::Create(std::move(curve), 0, 1, TargetProperty::FILTER);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
 
   AddAnimationToElementWithPlayer(child->element_id(), timeline_impl(),
                                   std::move(animation));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(GetRenderSurface(root));
-  EXPECT_TRUE(GetRenderSurface(child));
-  EXPECT_FALSE(GetRenderSurface(grandchild));
+  EXPECT_NE(GetRenderSurface(child), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(grandchild), GetRenderSurface(child));
 
   EXPECT_TRUE(GetRenderSurface(root)->Filters().IsEmpty());
   EXPECT_TRUE(GetRenderSurface(child)->Filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_FALSE(root->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(child->FilterIsAnimating());
   EXPECT_TRUE(child->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
   EXPECT_FALSE(grandchild->HasPotentiallyRunningFilterAnimation());
@@ skipping 690 matching lines @@
                                  page_scale_layer, inner_viewport_scroll_layer,
                                  outer_viewport_scroll_layer);
 
   TransformTree& transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owning_layer_id, significant_transform->id());
 
   EXPECT_TRUE(GetRenderSurface(root));
-  EXPECT_FALSE(GetRenderSurface(significant_transform));
+  EXPECT_EQ(GetRenderSurface(significant_transform), GetRenderSurface(root));
   EXPECT_TRUE(GetRenderSurface(layer_clips_subtree));
-  EXPECT_TRUE(GetRenderSurface(render_surface));
-  EXPECT_FALSE(GetRenderSurface(test_layer));
+  EXPECT_NE(GetRenderSurface(render_surface), GetRenderSurface(root));
+  EXPECT_EQ(GetRenderSurface(test_layer), GetRenderSurface(render_surface));
 
   EXPECT_EQ(gfx::Rect(30, 20), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
@@ skipping 995 matching lines @@
 
   // Check child layer draw properties.
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   EXPECT_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_EQ(gfx::Rect(10, 10), child->clip_rect());
   EXPECT_EQ(gfx::Rect(10, 10), child->drawable_content_rect());
 }
 
 }  // namespace
 }  // namespace cc