CC Animation: Use ElementId to attach CC animation players.

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 37 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
-  LayerWithForcedDrawsContent() {}
+  LayerWithForcedDrawsContent() { SetElementId(NextElementId()); }
 
   bool DrawsContent() const override;
 
  private:
   ~LayerWithForcedDrawsContent() override {}
 };
 
 bool LayerWithForcedDrawsContent::DrawsContent() const { return true; }
 
 class MockContentLayerClient : public ContentLayerClient {
@@ skipping 227 matching lines @@
   const float kDeviceScale = 1.666f;
 
   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_matrix;
   std::unique_ptr<LayerImpl> sublayer_scoped_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 1));
+      CreateTestLayerImpl(host_impl.active_tree(), 1));
   LayerImpl* sublayer = sublayer_scoped_ptr.get();
   sublayer->SetDrawsContent(true);
   SetLayerPropertiesForTesting(sublayer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(500, 500), true, false,
                                false);
 
   std::unique_ptr<LayerImpl> scroll_layer_scoped_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 2));
+      CreateTestLayerImpl(host_impl.active_tree(), 2));
   LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get();
   SetLayerPropertiesForTesting(scroll_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 20), true, false,
                                false);
   std::unique_ptr<LayerImpl> clip_layer_scoped_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 4));
+      CreateTestLayerImpl(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   SetScrollOffsetDelta(scroll_layer, kScrollDelta);
   gfx::Transform impl_transform;
   scroll_layer->AddChild(std::move(sublayer_scoped_ptr));
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
   clip_layer->AddChild(std::move(scroll_layer_scoped_ptr));
   scroll_layer_raw_ptr->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer_raw_ptr->id(),
                                                      kScrollOffset);
 
   std::unique_ptr<LayerImpl> root(
-      LayerImpl::Create(host_impl.active_tree(), 3));
+      CreateTestLayerImpl(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(3, 4), true, false,
                                false);
   root->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  scroll_layer->parent());
@@ skipping 270 matching lines @@
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
   std::unique_ptr<LayerImpl> child_replica =
-      LayerImpl::Create(host_impl()->active_tree(), 100);
+      CreateTestLayerImpl(host_impl()->active_tree(), 100);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                true);
 
   // Child is set up so that a new render surface should be created.
   child->SetOpacity(0.5f);
 
@@ skipping 75 matching lines @@
   LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2);
   child_of_rs2->SetDrawsContent(true);
   LayerImpl* grand_child_of_root = AddChild<LayerImpl>(child_of_root);
   grand_child_of_root->SetDrawsContent(true);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
   grand_child_of_rs1->SetDrawsContent(true);
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
   grand_child_of_rs2->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> replica_of_rs1 =
-      LayerImpl::Create(host_impl()->active_tree(), 101);
+      CreateTestLayerImpl(host_impl()->active_tree(), 101);
   std::unique_ptr<LayerImpl> replica_of_rs2 =
-      LayerImpl::Create(host_impl()->active_tree(), 102);
+      CreateTestLayerImpl(host_impl()->active_tree(), 102);
 
   // In combination with descendant draws content, opacity != 1 forces the layer
   // to have a new render surface.
   render_surface1->SetOpacity(0.5f);
   render_surface2->SetOpacity(0.33f);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
@@ skipping 1807 matching lines @@
       grand_child_of_root, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(
       grand_child_of_rs1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(
       grand_child_of_rs2, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
 
   // Put an animated opacity on the render surface.
-  AddOpacityTransitionToLayerWithPlayer(render_surface1->id(), timeline_impl(),
-                                        10.0, 1.f, 0.f, false);
+  AddOpacityTransitionToElementWithPlayer(
+      render_surface1->element_id(), timeline_impl(), 10.0, 1.f, 0.f, false);
 
   // Also put an animated opacity on a layer without descendants.
-  AddOpacityTransitionToLayerWithPlayer(grand_child_of_root->id(),
-                                        timeline_impl(), 10.0, 1.f, 0.f, false);
+  AddOpacityTransitionToElementWithPlayer(grand_child_of_root->element_id(),
+                                          timeline_impl(), 10.0, 1.f, 0.f,
+                                          false);
 
   // Put a transform animation on the render surface.
-  AddAnimatedTransformToLayerWithPlayer(render_surface2->id(), timeline_impl(),
-                                        10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(render_surface2->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
 
   // Also put transform animations on grand_child_of_root, and
   // grand_child_of_rs2
-  AddAnimatedTransformToLayerWithPlayer(grand_child_of_root->id(),
-                                        timeline_impl(), 10.0, 30, 0);
-  AddAnimatedTransformToLayerWithPlayer(grand_child_of_rs2->id(),
-                                        timeline_impl(), 10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(grand_child_of_root->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(grand_child_of_rs2->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
 
   ExecuteCalculateDrawProperties(parent);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(parent->render_surface());
   ASSERT_FALSE(child_of_root->render_surface());
   ASSERT_FALSE(grand_child_of_root->render_surface());
 
   ASSERT_TRUE(render_surface1->render_surface());
@@ skipping 103 matching lines @@
   SetLayerPropertiesForTesting(great_grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   // Add a transform animation with a start delay to |grand_child|.
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 0, 1,
       TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  AddAnimationToLayerWithPlayer(grand_child->id(), timeline_impl(),
-                                std::move(animation));
+  AddAnimationToElementWithPlayer(grand_child->element_id(), timeline_impl(),
+                                  std::move(animation));
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_FALSE(parent->screen_space_transform_is_animating());
   EXPECT_FALSE(child->screen_space_transform_is_animating());
 
   EXPECT_FALSE(grand_child->TransformIsAnimating());
   EXPECT_TRUE(grand_child->HasPotentiallyRunningTransformAnimation());
   EXPECT_TRUE(grand_child->screen_space_transform_is_animating());
   EXPECT_TRUE(great_grand_child->screen_space_transform_is_animating());
 }
@@ skipping 842 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest,
        OcclusionForLayerWithUninvertibleDrawTransform) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   std::unique_ptr<OutputSurface> output_surface = FakeOutputSurface::Create3d();
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 1);
+      CreateTestLayerImpl(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.active_tree(), 2);
+      CreateTestLayerImpl(host_impl.active_tree(), 2);
   std::unique_ptr<LayerImpl> grand_child =
-      LayerImpl::Create(host_impl.active_tree(), 3);
+      CreateTestLayerImpl(host_impl.active_tree(), 3);
   std::unique_ptr<LayerImpl> occluding_child =
-      LayerImpl::Create(host_impl.active_tree(), 4);
+      CreateTestLayerImpl(host_impl.active_tree(), 4);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   occluding_child->SetDrawsContent(true);
   occluding_child->SetContentsOpaque(true);
 
   gfx::Transform identity_matrix;
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
@@ skipping 617 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
   // Verify the behavior of back-face culling when there are no preserve-3d
   // layers. Note that 3d transforms still apply in this case, but they are
   // "flattened" to each parent layer according to current W3C spec.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> parent = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent>
       front_facing_child_of_front_facing_surface =
@@ skipping 242 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
   // Verify that layers are appropriately culled when their back face is showing
   // and they are not double sided, while animations are going on.
   //
   // Layers that are animating do not get culled on the main thread, as their
   // transforms should be treated as "unknown" so we can not be sure that their
   // back face is really showing.
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> parent = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> animating_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child_of_animating_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> animating_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 15 matching lines @@
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
   // Make our render surface.
   animating_surface->SetForceRenderSurfaceForTesting(true);
 
   // Animate the transform on the render surface.
-  AddAnimatedTransformToLayerWithPlayer(animating_surface->id(), timeline(),
-                                        10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(animating_surface->element_id(),
+                                          timeline(), 10.0, 30, 0);
   // This is just an animating layer, not a surface.
-  AddAnimatedTransformToLayerWithPlayer(animating_child->id(), timeline(), 10.0,
-                                        30, 0);
+  AddAnimatedTransformToElementWithPlayer(animating_child->element_id(),
+                                          timeline(), 10.0, 30, 0);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
                                backface_matrix,
@@ skipping 65 matching lines @@
   EXPECT_EQ(child_of_animating_surface->visible_layer_rect_for_testing(),
             gfx::Rect(child_of_animating_surface->bounds()));
 }
 
 TEST_F(LayerTreeHostCommonTest,
      BackFaceCullingWithPreserves3dForFlatteningSurface) {
   // Verify the behavior of back-face culling for a render surface that is
   // created when it flattens its subtree, and its parent has preserves-3d.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> parent = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(front_facing_surface);
@@ skipping 339 matching lines @@
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
 
   std::unique_ptr<LayerImpl> replica =
-      LayerImpl::Create(host_impl()->active_tree(), 7);
+      CreateTestLayerImpl(host_impl()->active_tree(), 7);
   SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
   // We need to set parent on replica layer for property tree building.
   replica->SetParent(child);
   child->SetReplicaLayer(std::move(replica));
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
   LayerImpl* duplicate_child_non_owner = AddChild<LayerImpl>(child);
@@ skipping 92 matching lines @@
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   std::unique_ptr<LayerImpl> replica =
-      LayerImpl::Create(host_impl()->active_tree(), 7);
+      CreateTestLayerImpl(host_impl()->active_tree(), 7);
   SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                false);
   child->SetReplicaLayer(std::move(replica));
 
   float device_scale_factor = 1.7f;
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
@@ skipping 14 matching lines @@
       child->render_surface()->replica_draw_transform());
 
   gfx::Transform expected_replica_screen_space_transform;
   expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSearch) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
-  scoped_refptr<Layer> mask_layer = Layer::Create();
-  scoped_refptr<Layer> replica_layer = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> child = CreateTestLayer();
+  scoped_refptr<Layer> grand_child = CreateTestLayer();
+  scoped_refptr<Layer> mask_layer = CreateTestLayer();
+  scoped_refptr<Layer> replica_layer = CreateTestLayer();
 
   grand_child->SetReplicaLayer(replica_layer.get());
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
   root->AddChild(child.get());
 
   host()->SetRootLayer(root);
 
   int nonexistent_id = -1;
   EXPECT_EQ(root.get(), host()->LayerById(root->id()));
   EXPECT_EQ(child.get(), host()->LayerById(child->id()));
   EXPECT_EQ(grand_child.get(), host()->LayerById(grand_child->id()));
   EXPECT_EQ(mask_layer.get(), host()->LayerById(mask_layer->id()));
   EXPECT_EQ(replica_layer.get(), host()->LayerById(replica_layer->id()));
   EXPECT_FALSE(host()->LayerById(nonexistent_id));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> child = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
@@ skipping 25 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(host()->settings(), &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   child->SetDrawsContent(true);
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  AddOpacityTransitionToLayerWithPlayer(child->id(), timeline, 10.0, 0.0f, 1.0f,
-                                        false);
+  AddOpacityTransitionToElementWithPlayer(child->element_id(), timeline, 10.0,
+                                          0.0f, 1.0f, false);
 
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
@@ skipping 73 matching lines @@
  protected:
   void SetUp() override {
     timeline_ =
         AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
     host_impl_.animation_host()->AddAnimationTimeline(timeline_);
 
     can_use_lcd_text_ = std::tr1::get<0>(GetParam());
     layers_always_allowed_lcd_text_ = std::tr1::get<1>(GetParam());
 
     std::unique_ptr<LayerImpl> root_ptr =
-        LayerImpl::Create(host_impl_.active_tree(), 1);
+        CreateTestLayerImpl(host_impl_.active_tree(), 1);
     std::unique_ptr<LayerImpl> child_ptr =
-        LayerImpl::Create(host_impl_.active_tree(), 2);
+        CreateTestLayerImpl(host_impl_.active_tree(), 2);
     std::unique_ptr<LayerImpl> grand_child_ptr =
-        LayerImpl::Create(host_impl_.active_tree(), 3);
+        CreateTestLayerImpl(host_impl_.active_tree(), 3);
 
     // Stash raw pointers to look at later.
     root_ = root_ptr.get();
     child_ = child_ptr.get();
     grand_child_ = grand_child_ptr.get();
 
     child_->AddChild(std::move(grand_child_ptr));
     root_->AddChild(std::move(child_ptr));
     host_impl_.active_tree()->SetRootLayer(std::move(root_ptr));
 
@@ skipping 142 matching lines @@
   // Sanity check: Make sure can_use_lcd_text_ is set on each node.
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 
   // Add opacity animation.
   child_->SetOpacity(0.9f);
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  AddOpacityTransitionToLayerWithPlayer(child_->id(), timeline(), 10.0, 0.9f,
-                                        0.1f, false);
+  AddOpacityTransitionToElementWithPlayer(child_->element_id(), timeline(),
+                                          10.0, 0.9f, 0.1f, false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   // Text LCD should be adjusted while animation is active.
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
 }
 
 TEST_P(LCDTextTest, CanUseLCDTextWithAnimationContentsOpaque) {
   bool expect_lcd_text = can_use_lcd_text_ || layers_always_allowed_lcd_text_;
   bool expect_not_lcd_text = layers_always_allowed_lcd_text_;
 
   // Sanity check: Make sure can_use_lcd_text_ is set on each node.
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 
   // Mark contents non-opaque within the first animation frame.
   child_->SetContentsOpaque(false);
-  AddOpacityTransitionToLayerWithPlayer(child_->id(), timeline(), 10.0, 0.9f,
-                                        0.1f, false);
+  AddOpacityTransitionToElementWithPlayer(child_->element_id(), timeline(),
+                                          10.0, 0.9f, 0.1f, false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   // LCD text should be disabled for non-opaque layers even during animations.
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(),
                                          testing::Bool(),
                                          testing::Bool()));
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   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;
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
   LayerImpl* root_layer = root.get();
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> grand_child =
-      LayerImpl::Create(host_impl.pending_tree(), 3);
+      CreateTestLayerImpl(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   host_impl.pending_tree()->SetRootLayer(std::move(root));
@@ skipping 15 matching lines @@
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   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;
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
   child->SetHideLayerAndSubtree(true);
 
   std::unique_ptr<LayerImpl> grand_child =
-      LayerImpl::Create(host_impl.pending_tree(), 3);
+      CreateTestLayerImpl(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   LayerImplList render_surface_layer_list;
@@ skipping 14 matching lines @@
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   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;
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(copy_grand_parent.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
                                true, false, false);
   copy_grand_parent->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_layer = copy_grand_parent.get();
 
   std::unique_ptr<LayerImpl> copy_parent =
-      LayerImpl::Create(host_impl.pending_tree(), 3);
+      CreateTestLayerImpl(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(copy_parent.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, true);
   copy_parent->SetDrawsContent(true);
   LayerImpl* copy_parent_layer = copy_parent.get();
 
   std::unique_ptr<LayerImpl> copy_request =
-      LayerImpl::Create(host_impl.pending_tree(), 4);
+      CreateTestLayerImpl(host_impl.pending_tree(), 4);
   SetLayerPropertiesForTesting(copy_request.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, true);
   copy_request->SetDrawsContent(true);
   LayerImpl* copy_layer = copy_request.get();
 
   std::unique_ptr<LayerImpl> copy_child =
-      LayerImpl::Create(host_impl.pending_tree(), 5);
+      CreateTestLayerImpl(host_impl.pending_tree(), 5);
   SetLayerPropertiesForTesting(copy_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, false);
   copy_child->SetDrawsContent(true);
   LayerImpl* copy_child_layer = copy_child.get();
 
   std::unique_ptr<LayerImpl> copy_grand_child =
-      LayerImpl::Create(host_impl.pending_tree(), 6);
+      CreateTestLayerImpl(host_impl.pending_tree(), 6);
   SetLayerPropertiesForTesting(copy_grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, false);
   copy_child->SetDrawsContent(true);
   LayerImpl* copy_grand_child_layer = copy_grand_child.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent_sibling_before =
-      LayerImpl::Create(host_impl.pending_tree(), 7);
+      CreateTestLayerImpl(host_impl.pending_tree(), 7);
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(),
                                identity_matrix, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(40, 40), true, false, false);
   copy_grand_parent_sibling_before->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_before_layer =
       copy_grand_parent_sibling_before.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent_sibling_after =
-      LayerImpl::Create(host_impl.pending_tree(), 8);
+      CreateTestLayerImpl(host_impl.pending_tree(), 8);
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
                                identity_matrix, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(40, 40), true, false, false);
   copy_grand_parent_sibling_after->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_after_layer =
       copy_grand_parent_sibling_after.get();
 
   copy_child->AddChild(std::move(copy_grand_child));
   copy_request->AddChild(std::move(copy_child));
   copy_parent->AddChild(std::move(copy_request));
@@ skipping 83 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   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;
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> copy_parent =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(copy_parent.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
                                false, false);
   copy_parent->SetDrawsContent(true);
   copy_parent->SetMasksToBounds(true);
 
   std::unique_ptr<LayerImpl> copy_layer =
-      LayerImpl::Create(host_impl.pending_tree(), 3);
+      CreateTestLayerImpl(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(copy_layer.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, true);
   copy_layer->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> copy_child =
-      LayerImpl::Create(host_impl.pending_tree(), 4);
+      CreateTestLayerImpl(host_impl.pending_tree(), 4);
   SetLayerPropertiesForTesting(copy_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, false);
   copy_child->SetDrawsContent(true);
 
   std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
@@ skipping 480 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
+      CreateTestLayerImpl(host_impl.active_tree(), 12345);
   std::unique_ptr<LayerImpl> child1 =
-      LayerImpl::Create(host_impl.active_tree(), 123456);
+      CreateTestLayerImpl(host_impl.active_tree(), 123456);
   std::unique_ptr<LayerImpl> child2 =
-      LayerImpl::Create(host_impl.active_tree(), 1234567);
+      CreateTestLayerImpl(host_impl.active_tree(), 1234567);
   std::unique_ptr<LayerImpl> child3 =
-      LayerImpl::Create(host_impl.active_tree(), 12345678);
+      CreateTestLayerImpl(host_impl.active_tree(), 12345678);
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, true);
   root->SetDrawsContent(true);
 
   // This layer structure normally forces render surface due to preserves3d
@@ skipping 712 matching lines @@
   //     + scroller
   //       + fixed
   //
   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();
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl.active_tree(), 1);
+      CreateTestLayerImpl(host_impl.active_tree(), 1);
   LayerImpl* root = root_ptr.get();
   std::unique_ptr<LayerImpl> container =
-      LayerImpl::Create(host_impl.active_tree(), 2);
+      CreateTestLayerImpl(host_impl.active_tree(), 2);
   LayerImpl* container_layer = container.get();
   std::unique_ptr<LayerImpl> scroller =
-      LayerImpl::Create(host_impl.active_tree(), 3);
+      CreateTestLayerImpl(host_impl.active_tree(), 3);
   LayerImpl* scroll_layer = scroller.get();
   std::unique_ptr<LayerImpl> fixed =
-      LayerImpl::Create(host_impl.active_tree(), 4);
+      CreateTestLayerImpl(host_impl.active_tree(), 4);
   LayerImpl* fixed_layer = fixed.get();
 
   container->test_properties()->is_container_for_fixed_position_layers = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
 
   scroller->SetScrollClipLayer(container->id());
 
@@ skipping 140 matching lines @@
   SetLayerPropertiesForTesting(scroller, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
 
   gfx::Transform end_scale;
   end_scale.Scale(2.f, 2.f);
   TransformOperations start_operations;
   start_operations.AppendMatrix(start_scale);
   TransformOperations end_operations;
   end_operations.AppendMatrix(end_scale);
-  AddAnimatedTransformToLayerWithPlayer(animated_layer->id(), timeline_impl(),
-                                        1.0, start_operations, end_operations);
+  AddAnimatedTransformToElementWithPlayer(animated_layer->element_id(),
+                                          timeline_impl(), 1.0,
+                                          start_operations, end_operations);
   gfx::Vector2dF scroll_delta(5.f, 9.f);
   SetScrollOffsetDelta(scroller, scroll_delta);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f);
   EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation,
                       scroller->DrawTransform().To2dTranslation());
 }
 
 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl {
  public:
   static std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id) {
-    return base::WrapUnique(
+    auto layer = base::WrapUnique(
         new AnimationScaleFactorTrackingLayerImpl(tree_impl, id));
+    layer->SetElementId(NextElementId());
+    return layer;
   }
 
   ~AnimationScaleFactorTrackingLayerImpl() override {}
 
  private:
   explicit AnimationScaleFactorTrackingLayerImpl(LayerTreeImpl* tree_impl,
                                                  int id)
       : LayerImpl(tree_impl, id) {
     SetDrawsContent(true);
   }
@@ skipping 65 matching lines @@
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   TransformOperations translation;
   translation.AppendTranslate(1.f, 2.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline;
   timeline = AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), translation);
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(),
+                                          translation);
 
   // No layers have scale-affecting 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(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 4.f, 3.f);
 
-  AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // Only |child| has a scale-affecting animation.
   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(5.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       5.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(1.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       1.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AddAnimatedTransformToLayerWithPlayer(grand_parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(grand_parent_raw->element_id(),
+                                          timeline, 1.0, TransformOperations(),
+                                          scale);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |child| have scale-affecting animations.
   EXPECT_EQ(
       5.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(5.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   // We don't support combining animated scales from two nodes; 0.f means
   // that the maximum scale could not be computed.
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       1.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(1.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
   EXPECT_EQ(
       5.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(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       1.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AbortAnimationsOnLayerWithPlayer(grand_parent_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
-  AbortAnimationsOnLayerWithPlayer(parent_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
-  AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(grand_parent_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(parent_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
-  AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
-                                        TransformOperations(), perspective);
+  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
+                                          1.0, TransformOperations(),
+                                          perspective);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a scale-affecting animation but computing the maximum of this
   // animation is not supported.
   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(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent_raw->SetTransform(scale_matrix);
   parent_raw->SetTransform(scale_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(10.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(10.f,
@@ skipping 116 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
   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_matrix;
 
   std::unique_ptr<LayerImpl> grand_parent =
-      LayerImpl::Create(host_impl.active_tree(), 1);
+      CreateTestLayerImpl(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> parent =
-      LayerImpl::Create(host_impl.active_tree(), 3);
+      CreateTestLayerImpl(host_impl.active_tree(), 3);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.active_tree(), 5);
+      CreateTestLayerImpl(host_impl.active_tree(), 5);
   std::unique_ptr<LayerImpl> grand_child1 =
-      LayerImpl::Create(host_impl.active_tree(), 7);
+      CreateTestLayerImpl(host_impl.active_tree(), 7);
   std::unique_ptr<LayerImpl> grand_child2 =
-      LayerImpl::Create(host_impl.active_tree(), 9);
+      CreateTestLayerImpl(host_impl.active_tree(), 9);
 
   LayerImpl* grand_parent_raw = grand_parent.get();
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
   child->AddChild(std::move(grand_child1));
   child->AddChild(std::move(grand_child2));
   parent->AddChild(std::move(child));
@@ skipping 87 matching lines @@
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add a mask layer to child.
-  child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
+  child_raw->SetMaskLayer(CreateTestLayerImpl(host_impl.active_tree(), 6));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(
       child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->mask_layer());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->mask_layer());
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add replica mask layer.
   std::unique_ptr<LayerImpl> replica_layer =
-      LayerImpl::Create(host_impl.active_tree(), 20);
-  replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 21));
+      CreateTestLayerImpl(host_impl.active_tree(), 20);
+  replica_layer->SetMaskLayer(CreateTestLayerImpl(host_impl.active_tree(), 21));
   child_raw->SetReplicaLayer(std::move(replica_layer));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(
       child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
@@ skipping 86 matching lines @@
 TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   LayerTreeSettings settings = host()->settings();
   settings.layer_transforms_should_scale_layer_contents = true;
   FakeLayerTreeHostImpl host_impl(settings, &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
 
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 1);
+      CreateTestLayerImpl(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   std::unique_ptr<LayerImpl> child1 =
-      LayerImpl::Create(host_impl.active_tree(), 2);
+      CreateTestLayerImpl(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   std::unique_ptr<LayerImpl> child2 =
-      LayerImpl::Create(host_impl.active_tree(), 3);
+      CreateTestLayerImpl(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->AddChild(std::move(child1));
   root->AddChild(std::move(child2));
   root->test_properties()->force_render_surface = true;
   root->SetDrawsContent(true);
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
 
-  child1_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4));
+  child1_layer->SetMaskLayer(CreateTestLayerImpl(host_impl.active_tree(), 4));
   child1_layer->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> replica_layer =
-      LayerImpl::Create(host_impl.active_tree(), 5);
-  replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
+      CreateTestLayerImpl(host_impl.active_tree(), 5);
+  replica_layer->SetMaskLayer(CreateTestLayerImpl(host_impl.active_tree(), 6));
   child1_layer->SetReplicaLayer(std::move(replica_layer));
   child1_layer->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  AddAnimatedTransformToLayerWithPlayer(child2_layer->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
 
   SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
   child2_layer->SetDrawsContent(true);
 
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale());
@@ skipping 144 matching lines @@
 
   // Sublayer should be bigger than the root enlarged by bounds_delta.
   gfx::Size sublayer_size = gfx::Size(300, 1000);
 
   // Device viewport accomidated the root and the top controls.
   gfx::Size device_viewport_size = gfx::Size(300, 600);
   gfx::Transform identity_matrix;
 
   host_impl.SetViewportSize(device_viewport_size);
   host_impl.active_tree()->SetRootLayer(
-      LayerImpl::Create(host_impl.active_tree(), 1));
+      CreateTestLayerImpl(host_impl.active_tree(), 1));
 
   LayerImpl* root = host_impl.active_tree()->root_layer();
   SetLayerPropertiesForTesting(root,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                root_size,
                                false,
                                false,
                                true);
   root->SetMasksToBounds(true);
 
-  root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
+  root->AddChild(CreateTestLayerImpl(host_impl.active_tree(), 2));
 
   LayerImpl* sublayer = root->child_at(0);
   SetLayerPropertiesForTesting(sublayer,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                sublayer_size,
                                false,
                                false,
                                false);
   sublayer->SetDrawsContent(true);
 
   LayerImplList layer_impl_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, device_viewport_size, &layer_impl_list);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect());
 
   root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, NodesAffectedByBoundsDeltaGetUpdated) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> inner_viewport_container_layer = Layer::Create();
-  scoped_refptr<Layer> inner_viewport_scroll_layer = Layer::Create();
-  scoped_refptr<Layer> outer_viewport_container_layer = Layer::Create();
-  scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> inner_viewport_container_layer = CreateTestLayer();
+  scoped_refptr<Layer> inner_viewport_scroll_layer = CreateTestLayer();
+  scoped_refptr<Layer> outer_viewport_container_layer = CreateTestLayer();
+  scoped_refptr<Layer> outer_viewport_scroll_layer = CreateTestLayer();
 
   root->AddChild(inner_viewport_container_layer);
   inner_viewport_container_layer->AddChild(inner_viewport_scroll_layer);
   inner_viewport_scroll_layer->AddChild(outer_viewport_container_layer);
   outer_viewport_container_layer->AddChild(outer_viewport_scroll_layer);
 
   inner_viewport_scroll_layer->SetScrollClipLayerId(
       inner_viewport_container_layer->id());
   outer_viewport_scroll_layer->SetScrollClipLayerId(
       outer_viewport_container_layer->id());
 
   inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
   outer_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
   host()->RegisterViewportLayers(nullptr, root, inner_viewport_scroll_layer,
                                  outer_viewport_scroll_layer);
 
-  scoped_refptr<Layer> fixed_to_inner = Layer::Create();
-  scoped_refptr<Layer> fixed_to_outer = Layer::Create();
+  scoped_refptr<Layer> fixed_to_inner = CreateTestLayer();
+  scoped_refptr<Layer> fixed_to_outer = CreateTestLayer();
 
   inner_viewport_scroll_layer->AddChild(fixed_to_inner);
   outer_viewport_scroll_layer->AddChild(fixed_to_outer);
 
   LayerPositionConstraint fixed_to_right;
   fixed_to_right.set_is_fixed_position(true);
   fixed_to_right.set_is_fixed_to_right_edge(true);
 
   fixed_to_inner->SetPositionConstraint(fixed_to_right);
   fixed_to_outer->SetPositionConstraint(fixed_to_right);
@@ skipping 14 matching lines @@
 
   fixed_to_outer->SetPositionConstraint(fixed_to_left);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetMasksToBounds(true);
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetOpacity(0.f);
 
-  AddOpacityTransitionToLayerWithPlayer(animated->id(), timeline(), 10.0, 0.f,
-                                        1.f, false);
+  AddOpacityTransitionToElementWithPlayer(animated->element_id(), timeline(),
+                                          10.0, 0.f, 1.f, false);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_FALSE(animated->visible_layer_rect_for_testing().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> clip = CreateTestLayer();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
@@ skipping 17 matching lines @@
   SetLayerPropertiesForTesting(surface.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(descendant_of_animation.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(200, 200), true, false);
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
-  AddAnimatedTransformToLayerWithPlayer(animated->id(), timeline(), 10.0,
-                                        start_transform_operations,
-                                        end_transform_operations);
+  AddAnimatedTransformToElementWithPlayer(animated->element_id(), timeline(),
+                                          10.0, start_transform_operations,
+                                          end_transform_operations);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   // The animated layer has a singular transform and maps to a non-empty rect in
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect_for_testing());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(2, 2),
@@ skipping 14 matching lines @@
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(),
             descendant_of_animation->visible_layer_rect_for_testing());
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grandchild = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> child = CreateTestLayer();
+  scoped_refptr<Layer> grandchild = CreateTestLayer();
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
                                true, false);
   host()->SetRootLayer(root);
 
-  AddAnimatedFilterToLayerWithPlayer(child->id(), timeline(), 10.0, 0.1f, 0.2f);
+  AddAnimatedFilterToElementWithPlayer(child->element_id(), timeline(), 10.0,
+                                       0.1f, 0.2f);
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->filters().IsEmpty());
   EXPECT_TRUE(child->filters().IsEmpty());
   EXPECT_TRUE(grandchild->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
 // render surface.
 TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grandchild = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> child = CreateTestLayer();
+  scoped_refptr<Layer> grandchild = CreateTestLayer();
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
                                true, false);
   host()->SetRootLayer(root);
 
   std::unique_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(0.1f));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(0.3f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   curve->AddKeyframe(FilterKeyframe::Create(
       base::TimeDelta::FromMilliseconds(100), end_filters, nullptr));
   std::unique_ptr<Animation> animation =
       Animation::Create(std::move(curve), 0, 1, TargetProperty::FILTER);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
 
-  AddAnimationToLayerWithPlayer(child->id(), timeline(), std::move(animation));
+  AddAnimationToElementWithPlayer(child->element_id(), timeline(),
+                                  std::move(animation));
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->filters().IsEmpty());
   EXPECT_TRUE(child->filters().IsEmpty());
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
@@ skipping 75 matching lines @@
 TEST_F(LayerTreeHostCommonTest, CombineClipsUsingContentTarget) {
   // In the following layer tree, the layer |box|'s render target is |surface|.
   // |surface| also creates a transform node. We want to combine clips for |box|
   // in the space of its target (i.e., |surface|), not its target's target. This
   // test ensures that happens.
 
   gfx::Transform rotate;
   rotate.Rotate(5);
   gfx::Transform identity;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 1500), true,
                                false);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create();
+  scoped_refptr<Layer> frame_clip = CreateTestLayer();
   SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 1500), true,
                                false);
   frame_clip->SetMasksToBounds(true);
 
-  scoped_refptr<Layer> rotated = Layer::Create();
+  scoped_refptr<Layer> rotated = CreateTestLayer();
   SetLayerPropertiesForTesting(rotated.get(), rotate,
                                gfx::Point3F(1250, 250, 0), gfx::PointF(),
                                gfx::Size(2500, 500), true, false);
 
-  scoped_refptr<Layer> surface = Layer::Create();
+  scoped_refptr<Layer> surface = CreateTestLayer();
   SetLayerPropertiesForTesting(surface.get(), rotate, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 500), true,
                                false);
   surface->SetOpacity(0.5);
 
   scoped_refptr<LayerWithForcedDrawsContent> container =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(container.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(300, 300), true, false);
 
@@ skipping 86 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangingAxisAlignmentTriggersRebuild) {
   gfx::Transform identity;
   gfx::Transform translate;
   gfx::Transform rotate;
 
   translate.Translate(10, 10);
   rotate.Rotate(45);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(translate);
@@ skipping 70 matching lines @@
 static void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, NumCopyRequestsInTargetSubtree) {
   // If the layer has a node in effect_tree, the return value of
   // num_copy_requests_in_target_subtree()  must be equal to the actual number
   // of copy requests in the sub-layer_tree; Otherwise, the number is expected
   // to be the value of its nearest ancestor that owns an effect node and
   // greater than or equal to the actual number of copy requests in the
   // sub-layer_tree.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child1 = Layer::Create();
-  scoped_refptr<Layer> child2 = Layer::Create();
-  scoped_refptr<Layer> grandchild = Layer::Create();
-  scoped_refptr<Layer> greatgrandchild = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> child1 = CreateTestLayer();
+  scoped_refptr<Layer> child2 = CreateTestLayer();
+  scoped_refptr<Layer> grandchild = CreateTestLayer();
+  scoped_refptr<Layer> greatgrandchild = CreateTestLayer();
 
   root->AddChild(child1);
   root->AddChild(child2);
   child1->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
   host()->SetRootLayer(root);
 
   child1->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   greatgrandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   child2->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_EQ(root->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child1->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child2->num_copy_requests_in_target_subtree(), 0);
   EXPECT_EQ(grandchild->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(greatgrandchild->num_copy_requests_in_target_subtree(), 1);
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
   gfx::Transform identity;
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<FakePictureLayer> greatgrandchild(
       FakePictureLayer::Create(&client));
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
@@ skipping 37 matching lines @@
   child->SetTransform(zero_z_scale);
 
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)),
       animation_id, 1, TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  AddAnimationToLayerWithPlayer(child->id(), timeline(), std::move(animation));
+  AddAnimationToElementWithPlayer(child->element_id(), timeline(),
+                                  std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
   grandchild->set_visible_layer_rect(gfx::Rect());
 
-  RemoveAnimationFromLayerWithExistingPlayer(child->id(), timeline(),
-                                             animation_id);
+  RemoveAnimationFromElementWithExistingPlayer(child->element_id(), timeline(),
+                                               animation_id);
   child->SetTransform(identity);
   child->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
 
   // 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.
   grandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
   greatgrandchild->set_visible_layer_rect(gfx::Rect());
 
   // Add an opacity animation with a start delay.
   animation_id = 1;
   animation = Animation::Create(
       std::unique_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));
+  AddAnimationToElementWithExistingPlayer(child->element_id(), timeline(),
+                                          std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
 }
 
 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;
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 1);
+      CreateTestLayerImpl(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.active_tree(), 2);
+      CreateTestLayerImpl(host_impl.active_tree(), 2);
   std::unique_ptr<LayerImpl> grandchild =
-      LayerImpl::Create(host_impl.active_tree(), 3);
+      CreateTestLayerImpl(host_impl.active_tree(), 3);
 
   std::unique_ptr<FakePictureLayerImpl> greatgrandchild(
       FakePictureLayerImpl::Create(host_impl.active_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,
@@ skipping 103 matching lines @@
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_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()->RegisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(root_ptr->id())
+      ->GetElementAnimationsForElementId(root_ptr->element_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(0, 0), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform identity;
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, true);
@@ skipping 20 matching lines @@
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_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()->RegisterPlayerForElement(
-      grand_child->id(), player.get());
+      grand_child->element_id(), player.get());
   host_impl()
       ->active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(grand_child->id())
+      ->GetElementAnimationsForElementId(grand_child->element_id())
       ->AddAnimation(std::move(transform_animation));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), grand_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 
   host_impl()->active_tree()->animation_host()->UnregisterPlayerForElement(
-      grand_child->id(), player.get());
+      grand_child->element_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();
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.pending_tree(), 1);
+      CreateTestLayerImpl(host_impl.pending_tree(), 1);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl.pending_tree(), 2);
+      CreateTestLayerImpl(host_impl.pending_tree(), 2);
   std::unique_ptr<LayerImpl> grandchild =
-      LayerImpl::Create(host_impl.pending_tree(), 3);
+      CreateTestLayerImpl(host_impl.pending_tree(), 3);
 
   std::unique_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,
@@ skipping 21 matching lines @@
       KeyframedFloatAnimationCurve::Create());
   std::unique_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));
   std::unique_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()->RegisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(root_ptr->id())
+      ->GetElementAnimationsForElementId(root_ptr->element_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()->UnregisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
@@ skipping 28 matching lines @@
 
   child->SetOpacity(0.f);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
   // PreCalculateMetaInformation happens when its required.
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
+  scoped_refptr<Layer> parent = CreateTestLayer();
+  scoped_refptr<Layer> child = CreateTestLayer();
 
   root->AddChild(parent);
   parent->AddChild(child);
 
   child->SetClipParent(root.get());
 
   gfx::Transform identity;
 
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
@@ skipping 37 matching lines @@
   child->SetTouchEventHandlerRegion(gfx::Rect());
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(root->layer_or_descendant_has_touch_handler(), false);
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = CreateTestLayer();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
 
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> child = CreateTestLayer();
   SetLayerPropertiesForTesting(child.get(), translate_z, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
 
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_NE(-1, child->transform_tree_index());
 
@@ skipping 574 matching lines @@
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(30, 30), true, false, false);
   root->SetDrawsContent(true);
   child->SetDrawsContent(false);
-  child->SetMaskLayer(LayerImpl::Create(root->layer_tree_impl(), 100));
+  child->SetMaskLayer(CreateTestLayerImpl(root->layer_tree_impl(), 100));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   child->mask_layer()->ScreenSpaceTransform());
   transform.Translate(10, 10);
   child->SetTransform(transform);
   child->SetDrawsContent(true);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
@@ skipping 162 matching lines @@
   // +----node---owner:5, id:6
   //
   // Extra check:
   //   scroll_tree_index() of:
   //     grand_child10:3
   //     parent3:1
   //     child8:4
   //     parent4:1
   //     child9:1
   //     grand_child12:1
-  scoped_refptr<Layer> root1 = Layer::Create();
-  scoped_refptr<Layer> page_scale_layer = Layer::Create();
-  scoped_refptr<Layer> parent2 = Layer::Create();
-  scoped_refptr<Layer> parent3 = Layer::Create();
-  scoped_refptr<Layer> parent4 = Layer::Create();
-  scoped_refptr<Layer> parent5 = Layer::Create();
-  scoped_refptr<Layer> child6 = Layer::Create();
-  scoped_refptr<Layer> child7 = Layer::Create();
-  scoped_refptr<Layer> child8 = Layer::Create();
-  scoped_refptr<Layer> child9 = Layer::Create();
-  scoped_refptr<Layer> grand_child10 = Layer::Create();
-  scoped_refptr<Layer> grand_child11 = Layer::Create();
-  scoped_refptr<Layer> grand_child12 = Layer::Create();
+  scoped_refptr<Layer> root1 = CreateTestLayer();
+  scoped_refptr<Layer> page_scale_layer = CreateTestLayer();
+  scoped_refptr<Layer> parent2 = CreateTestLayer();
+  scoped_refptr<Layer> parent3 = CreateTestLayer();
+  scoped_refptr<Layer> parent4 = CreateTestLayer();
+  scoped_refptr<Layer> parent5 = CreateTestLayer();
+  scoped_refptr<Layer> child6 = CreateTestLayer();
+  scoped_refptr<Layer> child7 = CreateTestLayer();
+  scoped_refptr<Layer> child8 = CreateTestLayer();
+  scoped_refptr<Layer> child9 = CreateTestLayer();
+  scoped_refptr<Layer> grand_child10 = CreateTestLayer();
+  scoped_refptr<Layer> grand_child11 = CreateTestLayer();
+  scoped_refptr<Layer> grand_child12 = CreateTestLayer();
 
   root1->AddChild(page_scale_layer);
   page_scale_layer->AddChild(parent2);
   page_scale_layer->AddChild(parent3);
   page_scale_layer->AddChild(parent4);
   page_scale_layer->AddChild(parent5);
   parent2->AddChild(child6);
   parent3->AddChild(child7);
   parent3->AddChild(child8);
   parent4->AddChild(child9);
@@ skipping 42 matching lines @@
   property_tree_root->data.contains_non_fast_scrollable_region = false;
   property_tree_root->data.transform_id = kRootPropertyTreeNodeId;
 
   // The node owned by root1
   ScrollNode scroll_root1;
   scroll_root1.id = 1;
   scroll_root1.owner_id = root1->id();
   scroll_root1.data.user_scrollable_horizontal = true;
   scroll_root1.data.user_scrollable_vertical = true;
   scroll_root1.data.transform_id = root1->transform_tree_index();
+  scroll_root1.data.element_id = root1->element_id();
   expected_scroll_tree.Insert(scroll_root1, 0);
 
   // The node owned by parent2
   ScrollNode scroll_parent2;
   scroll_parent2.id = 2;
   scroll_parent2.owner_id = parent2->id();
   scroll_parent2.data.scrollable = true;
   scroll_parent2.data.main_thread_scrolling_reasons =
       parent2->main_thread_scrolling_reasons();
   scroll_parent2.data.scroll_clip_layer_bounds = root1->bounds();
   scroll_parent2.data.bounds = parent2->bounds();
   scroll_parent2.data.max_scroll_offset_affected_by_page_scale = true;
   scroll_parent2.data.is_inner_viewport_scroll_layer = true;
   scroll_parent2.data.user_scrollable_horizontal = true;
   scroll_parent2.data.user_scrollable_vertical = true;
   scroll_parent2.data.transform_id = parent2->transform_tree_index();
+  scroll_parent2.data.element_id = parent2->element_id();
   expected_scroll_tree.Insert(scroll_parent2, 1);
 
   // The node owned by child6
   ScrollNode scroll_child6;
   scroll_child6.id = 3;
   scroll_child6.owner_id = child6->id();
   scroll_child6.data.main_thread_scrolling_reasons =
       child6->main_thread_scrolling_reasons();
   scroll_child6.data.should_flatten = true;
   scroll_child6.data.user_scrollable_horizontal = true;
   scroll_child6.data.user_scrollable_vertical = true;
   scroll_child6.data.transform_id = child6->transform_tree_index();
+  scroll_child6.data.element_id = child6->element_id();
   expected_scroll_tree.Insert(scroll_child6, 2);
 
   // The node owned by child7, child7 also owns a transform node
   ScrollNode scroll_child7;
   scroll_child7.id = 4;
   scroll_child7.owner_id = child7->id();
   scroll_child7.data.scrollable = true;
   scroll_child7.data.scroll_clip_layer_bounds = parent3->bounds();
   scroll_child7.data.bounds = child7->bounds();
   scroll_child7.data.user_scrollable_horizontal = true;
   scroll_child7.data.user_scrollable_vertical = true;
   scroll_child7.data.transform_id = child7->transform_tree_index();
+  scroll_child7.data.element_id = child7->element_id();
   expected_scroll_tree.Insert(scroll_child7, 1);
 
   // The node owned by grand_child11, grand_child11 also owns a transform node
   ScrollNode scroll_grand_child11;
   scroll_grand_child11.id = 5;
   scroll_grand_child11.owner_id = grand_child11->id();
   scroll_grand_child11.data.scrollable = true;
   scroll_grand_child11.data.user_scrollable_horizontal = true;
   scroll_grand_child11.data.user_scrollable_vertical = true;
   scroll_grand_child11.data.transform_id =
       grand_child11->transform_tree_index();
+  scroll_grand_child11.data.element_id = grand_child11->element_id();
   expected_scroll_tree.Insert(scroll_grand_child11, 4);
 
   // The node owned by parent5
   ScrollNode scroll_parent5;
   scroll_parent5.id = 8;
   scroll_parent5.owner_id = parent5->id();
   scroll_parent5.data.contains_non_fast_scrollable_region = true;
   scroll_parent5.data.bounds = gfx::Size(10, 10);
   scroll_parent5.data.should_flatten = true;
   scroll_parent5.data.user_scrollable_horizontal = true;
   scroll_parent5.data.user_scrollable_vertical = true;
   scroll_parent5.data.transform_id = parent5->transform_tree_index();
+  scroll_parent5.data.element_id = parent5->element_id();
   expected_scroll_tree.Insert(scroll_parent5, 1);
 
   expected_scroll_tree.SetScrollOffset(parent2->id(), gfx::ScrollOffset(0, 0));
   expected_scroll_tree.SetScrollOffset(child7->id(), gfx::ScrollOffset(0, 0));
   expected_scroll_tree.SetScrollOffset(grand_child11->id(),
                                        gfx::ScrollOffset(0, 0));
   expected_scroll_tree.set_needs_update(false);
 
   EXPECT_EQ(expected_scroll_tree, scroll_tree);
 
   // Check other layers' scroll_tree_index
   EXPECT_EQ(scroll_root1.id, page_scale_layer->scroll_tree_index());
   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