Update from https://crrev.com/309717

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 66 matching lines @@
         LayerImpl::Create(host_impl_.active_tree(), 42);
     scoped_ptr<LayerImpl> scroll_layer =
         LayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 3);
     scoped_ptr<LayerImpl> great_grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 4);
 
+    root->SetHasRenderSurface(true);
     gfx::Transform IdentityMatrix;
     gfx::Point3F transform_origin;
     gfx::PointF position;
     gfx::Size bounds(200, 200);
     gfx::Size clip_bounds(100, 100);
     SetLayerPropertiesForTesting(scroll_layer.get(),
                                  IdentityMatrix,
                                  transform_origin,
                                  position,
                                  bounds,
@@ skipping 495 matching lines @@
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer. In this case, the surface draw transforms also have to be accounted
   // for when checking the scroll delta.
   LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
-  grand_child->SetForceRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
   grand_child->SetTransform(rotation_about_z);
 
   // Case 1: scroll delta of 0, 0
   child->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
@@ skipping 119 matching lines @@
                                  gfx::PointF(),
                                  gfx::Size(100, 100),
                                  true);
     great_grand_child->AddChild(fixed_position_child.Pass());
   }
   LayerImpl* fixed_position_child = great_grand_child->children()[0];
 
   // Actually set up the scenario here.
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
-  grand_child->SetForceRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   great_grand_child->SetPosition(gfx::PointF(40.f, 60.f));
-  great_grand_child->SetForceRenderSurface(true);
+  great_grand_child->SetHasRenderSurface(true);
   fixed_position_child->SetPositionConstraint(fixed_to_top_left_);
   fixed_position_child->SetDrawsContent(true);
 
   // The additional rotations, which are non-commutative with translations, help
   // to verify that we have correct order-of-operations in the final scroll
   // compensation.  Note that rotating about the center of the layer ensures we
   // do not accidentally clip away layers that we want to test.
   gfx::Transform rotation_about_z;
   rotation_about_z.Translate(50.0, 50.0);
   rotation_about_z.RotateAboutZAxis(90.0);
@@ skipping 145 matching lines @@
      ScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface) {
   // This test checks for correct scroll compensation when the fixed-position
   // container itself has a render surface. In this case, the container layer
   // should be treated like a layer that contributes to a render target, and
   // that render target is completely irrelevant; it should not affect the
   // scroll compensation.
   LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
-  child->SetForceRenderSurface(true);
+  child->SetHasRenderSurface(true);
   grand_child->SetPositionConstraint(fixed_to_top_left_);
   grand_child->SetDrawsContent(true);
 
   // Case 1: scroll delta of 0, 0
   child->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
 
   gfx::Transform expected_surface_draw_transform;
   expected_surface_draw_transform.Translate(0.0, 0.0);
   gfx::Transform expected_child_transform;
@@ skipping 228 matching lines @@
                                   fixed_to_container1->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
                                   container2->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
                                   fixed_to_container2->draw_transform());
 }
 }  // namespace
 }  // namespace cc