Update from https://crrev.com/320931

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 <algorithm>
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 988 matching lines @@
 TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
   // For layers that flatten their subtree, there should be an orthographic
   // projection (for x and y values) in the middle of the transform sequence.
   // Note that the way the code is currently implemented, it is not expected to
   // use a canonical orthographic projection.
 
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
+  scoped_refptr<LayerWithForcedDrawsContent> great_grand_child =
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
                                rotation_about_y_axis,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
   SetLayerPropertiesForTesting(grand_child.get(),
                                rotation_about_y_axis,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
+  SetLayerPropertiesForTesting(great_grand_child.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
+                               true, false);
 
   root->AddChild(child);
   child->AddChild(grand_child);
+  grand_child->AddChild(great_grand_child);
   child->SetForceRenderSurface(true);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // No layers in this test should preserve 3d.
   ASSERT_TRUE(root->should_flatten_transform());
   ASSERT_TRUE(child->should_flatten_transform());
   ASSERT_TRUE(grand_child->should_flatten_transform());
+  ASSERT_TRUE(great_grand_child->should_flatten_transform());
 
   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
   gfx::Transform expected_child_screen_space_transform = rotation_about_y_axis;
   gfx::Transform expected_grand_child_draw_transform =
       rotation_about_y_axis;  // draws onto child's render surface
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
   gfx::Transform expected_grand_child_screen_space_transform =
       flattened_rotation_about_y * rotation_about_y_axis;
+  gfx::Transform expected_great_grand_child_draw_transform =
+      flattened_rotation_about_y;
+  gfx::Transform expected_great_grand_child_screen_space_transform =
+      flattened_rotation_about_y * flattened_rotation_about_y;
 
   ExecuteCalculateDrawProperties(root.get());
 
   // The child's draw transform should have been taken by its surface.
   ASSERT_TRUE(child->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_screen_space_transform,
       child->render_surface()->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
                                   grand_child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->screen_space_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
+                                  great_grand_child->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected_great_grand_child_screen_space_transform,
+      great_grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
   // A layer that is empty in one axis, but not the other, was accidentally
   // skipping a necessary translation.  Without that translation, the coordinate
   // space of the layer's draw transform is incorrect.
   //
   // Normally this isn't a problem, because the layer wouldn't be drawn anyway,
   // but if that layer becomes a render surface, then its draw transform is
   // implicitly inherited by the rest of the subtree, which then is positioned
@@ skipping 5925 matching lines @@
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     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;
+    auto end = LayerIterator<LayerImpl>::End(&render_surface_layer_list);
+    for (auto it = LayerIterator<LayerImpl>::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;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     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;
+    auto end = LayerIterator<LayerImpl>::End(&render_surface_layer_list);
+    for (auto it = LayerIterator<LayerImpl>::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++;
+    }
+
+    // Only root layer has a render surface.
+    EXPECT_EQ(1, count_represents_target_render_surface);
+    // No layer contributes a render surface to root render surface.
+    EXPECT_EQ(0, count_represents_contributing_render_surface);
+    // All 4 layers represent itself.
+    EXPECT_EQ(4, count_represents_itself);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent);
 
   root->AddChild(render_surface);
@@ skipping 1753 matching lines @@
   surface->AddChild(box);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 }
 
 }  // namespace
 }  // namespace cc