CC Animation: Use ElementId to attach CC animation players.

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 263 matching lines @@
     // Create both an inner viewport scroll layer and an outer viewport scroll
     // layer. The MaxScrollOffset of the outer viewport scroll layer will be
     // 0x0, so the scrolls will be applied directly to the inner viewport.
     const int kOuterViewportClipLayerId = 116;
     const int kOuterViewportScrollLayerId = 117;
     const int kContentLayerId = 118;
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
 
-    std::unique_ptr<LayerImpl> root = LayerImpl::Create(layer_tree_impl, 1);
+    std::unique_ptr<LayerImpl> root = CreateTestLayerImpl(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetPosition(gfx::PointF());
     root->test_properties()->force_render_surface = true;
 
     std::unique_ptr<LayerImpl> inner_scroll =
-        LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->test_properties()->is_container_for_fixed_position_layers =
         true;
     inner_scroll->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(inner_scroll->id(),
                                                        gfx::ScrollOffset());
 
     std::unique_ptr<LayerImpl> inner_clip =
-        LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     std::unique_ptr<LayerImpl> page_scale =
-        LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(content_size);
     inner_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> outer_clip =
-        LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(content_size);
     outer_clip->test_properties()->is_container_for_fixed_position_layers =
         true;
 
     std::unique_ptr<LayerImpl> outer_scroll =
-        LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(outer_scroll->id(),
                                                        gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> contents =
-        LayerImpl::Create(layer_tree_impl, kContentLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kContentLayerId);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(std::move(contents));
     outer_clip->AddChild(std::move(outer_scroll));
     inner_scroll->AddChild(std::move(outer_clip));
     page_scale->AddChild(std::move(inner_scroll));
     inner_clip->AddChild(std::move(page_scale));
     root->AddChild(std::move(inner_clip));
@@ skipping 44 matching lines @@
 
     return content_layer;
   }
 
   std::unique_ptr<LayerImpl> CreateScrollableLayer(int id,
                                                    const gfx::Size& size,
                                                    LayerImpl* clip_layer) {
     DCHECK(clip_layer);
     DCHECK(id != clip_layer->id());
     std::unique_ptr<LayerImpl> layer =
-        LayerImpl::Create(host_impl_->active_tree(), id);
+        CreateTestLayerImpl(host_impl_->active_tree(), id);
     layer->SetScrollClipLayer(clip_layer->id());
     layer->SetDrawsContent(true);
     layer->SetBounds(size);
     clip_layer->SetBounds(gfx::Size(size.width() / 2, size.height() / 2));
     return layer;
   }
 
   std::unique_ptr<ScrollState> BeginState(const gfx::Point& point) {
     ScrollStateData scroll_state_data;
     scroll_state_data.is_beginning = true;
@@ skipping 49 matching lines @@
   void pinch_zoom_pan_viewport_forces_commit_redraw(float device_scale_factor);
   void pinch_zoom_pan_viewport_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_boundary_test(
       float device_scale_factor);
 
   void SetupMouseMoveAtWithDeviceScale(float device_scale_factor);
 
   scoped_refptr<AnimationTimeline> timeline() { return timeline_; }
 
+  std::unique_ptr<LayerImpl> CreateTestLayerImpl(LayerTreeImpl* tree_impl,
+                                                 int id) {
+    auto layer = LayerImpl::Create(tree_impl, id);
+    layer->SetElementId(NextTestElementId());
+    return layer;
+  }
+
  protected:
   virtual std::unique_ptr<OutputSurface> CreateOutputSurface() {
     return FakeOutputSurface::Create3d();
   }
 
   void DrawOneFrame() {
     LayerTreeHostImpl::FrameData frame_data;
     PrepareToDrawFrame(&frame_data);
     host_impl_->DidDrawAllLayers(frame_data);
   }
@@ skipping 111 matching lines @@
   ASSERT_FALSE(host_impl_->active_tree()->root_layer());
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info =
       host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaTreeButNoChanges) {
   {
     std::unique_ptr<LayerImpl> root =
-        LayerImpl::Create(host_impl_->active_tree(), 1);
-    root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
-    root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 3));
+        CreateTestLayerImpl(host_impl_->active_tree(), 1);
+    root->AddChild(CreateTestLayerImpl(host_impl_->active_tree(), 2));
+    root->AddChild(CreateTestLayerImpl(host_impl_->active_tree(), 3));
     root->children()[1]->AddChild(
-        LayerImpl::Create(host_impl_->active_tree(), 4));
+        CreateTestLayerImpl(host_impl_->active_tree(), 4));
     root->children()[1]->AddChild(
-        LayerImpl::Create(host_impl_->active_tree(), 5));
+        CreateTestLayerImpl(host_impl_->active_tree(), 5));
     root->children()[1]->children()[0]->AddChild(
-        LayerImpl::Create(host_impl_->active_tree(), 6));
+        CreateTestLayerImpl(host_impl_->active_tree(), 6));
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   ExpectClearedScrollDeltasRecursive(root);
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info;
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
   gfx::ScrollOffset scroll_offset(20, 30);
   gfx::Vector2d scroll_delta(11, -15);
   {
     std::unique_ptr<LayerImpl> root_clip =
-        LayerImpl::Create(host_impl_->active_tree(), 2);
+        CreateTestLayerImpl(host_impl_->active_tree(), 2);
     std::unique_ptr<LayerImpl> root =
-        LayerImpl::Create(host_impl_->active_tree(), 1);
+        CreateTestLayerImpl(host_impl_->active_tree(), 1);
     root_clip->SetBounds(gfx::Size(10, 10));
     LayerImpl* root_layer = root.get();
     root_clip->AddChild(std::move(root));
     root_layer->SetBounds(gfx::Size(110, 110));
     root_layer->SetScrollClipLayer(root_clip->id());
     root_layer->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(root_layer->id(),
                                                        scroll_offset);
     host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
@@ skipping 165 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ScrollBlocksOnTouchEventHandlers) {
   LayerImpl* scroll = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   LayerImpl* child = 0;
   {
     std::unique_ptr<LayerImpl> child_layer =
-        LayerImpl::Create(host_impl_->active_tree(), 6);
+        CreateTestLayerImpl(host_impl_->active_tree(), 6);
     child = child_layer.get();
     child_layer->SetDrawsContent(true);
     child_layer->SetPosition(gfx::PointF(0, 20));
     child_layer->SetBounds(gfx::Size(50, 50));
     scroll->AddChild(std::move(child_layer));
     SetNeedsRebuildPropertyTrees();
     RebuildPropertyTrees();
   }
 
   // Touch handler regions determine whether touch events block scroll.
@@ skipping 113 matching lines @@
             status.main_thread_scrolling_reasons);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithOverlappingNonScrollableLayer) {
   LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
   gfx::Size content_size = gfx::Size(360, 600);
   gfx::Size scroll_content_size = gfx::Size(345, 3800);
   gfx::Size scrollbar_size = gfx::Size(15, 600);
 
   host_impl_->SetViewportSize(content_size);
-  std::unique_ptr<LayerImpl> root = LayerImpl::Create(layer_tree_impl, 1);
+  std::unique_ptr<LayerImpl> root = CreateTestLayerImpl(layer_tree_impl, 1);
   root->SetBounds(content_size);
   root->SetPosition(gfx::PointF());
 
-  std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 2);
+  std::unique_ptr<LayerImpl> clip = CreateTestLayerImpl(layer_tree_impl, 2);
   clip->SetBounds(content_size);
   clip->SetPosition(gfx::PointF());
 
-  std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 3);
+  std::unique_ptr<LayerImpl> scroll = CreateTestLayerImpl(layer_tree_impl, 3);
   scroll->SetBounds(scroll_content_size);
   scroll->SetScrollClipLayer(clip->id());
   scroll->SetDrawsContent(true);
 
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
       SolidColorScrollbarLayerImpl::Create(layer_tree_impl, 4, VERTICAL, 10, 0,
                                            false, true);
   scrollbar->SetBounds(scrollbar_size);
   scrollbar->SetPosition(gfx::PointF(345, 0));
   scrollbar->SetScrollLayerId(scroll->id());
   scrollbar->SetDrawsContent(true);
   scrollbar->SetOpacity(1.f);
 
-  std::unique_ptr<LayerImpl> squash1 = LayerImpl::Create(layer_tree_impl, 5);
+  std::unique_ptr<LayerImpl> squash1 = CreateTestLayerImpl(layer_tree_impl, 5);
   squash1->SetBounds(gfx::Size(140, 300));
   squash1->SetPosition(gfx::PointF(220, 0));
   squash1->SetDrawsContent(true);
 
-  std::unique_ptr<LayerImpl> squash2 = LayerImpl::Create(layer_tree_impl, 6);
+  std::unique_ptr<LayerImpl> squash2 = CreateTestLayerImpl(layer_tree_impl, 6);
   squash2->SetBounds(gfx::Size(140, 300));
   squash2->SetPosition(gfx::PointF(220, 300));
   squash2->SetDrawsContent(true);
 
   scroll->AddChild(std::move(squash2));
   clip->AddChild(std::move(scroll));
   clip->AddChild(std::move(scrollbar));
   clip->AddChild(std::move(squash1));
   root->AddChild(std::move(clip));
 
@@ skipping 312 matching lines @@
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), overflow->CurrentScrollOffset());
 }
 
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingPendingTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetRootLayer(
-      LayerImpl::Create(host_impl_->pending_tree(), 1));
+      CreateTestLayerImpl(host_impl_->pending_tree(), 1));
   LayerImpl* root = host_impl_->pending_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
   root->test_properties()->force_render_surface = true;
 
-  root->AddChild(LayerImpl::Create(host_impl_->pending_tree(), 2));
+  root->AddChild(CreateTestLayerImpl(host_impl_->pending_tree(), 2));
   LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
-  AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 10.0, 3, 0);
+  AddAnimatedTransformToElementWithPlayer(child->element_id(), timeline(), 10.0,
+                                          3, 0);
 
   EXPECT_FALSE(did_request_next_frame_);
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   host_impl_->AnimatePendingTreeAfterCommit();
 
   // An animation exists on the pending layer. Doing
   // AnimatePendingTreeAfterCommit() requests another frame.
   // In reality, animations without has_set_start_time() == true do not need to
@@ skipping 19 matching lines @@
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingActiveTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   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();
   root->SetBounds(gfx::Size(50, 50));
   root->test_properties()->force_render_surface = true;
 
-  root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
+  root->AddChild(CreateTestLayerImpl(host_impl_->active_tree(), 2));
   LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   // Add a translate from 6,7 to 8,9.
   TransformOperations start;
   start.AppendTranslate(6.f, 7.f, 0.f);
   TransformOperations end;
   end.AppendTranslate(8.f, 9.f, 0.f);
-  AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 4.0, start,
-                                        end);
+  AddAnimatedTransformToElementWithPlayer(child->element_id(), timeline(), 4.0,
+                                          start, end);
 
   base::TimeTicks now = base::TimeTicks::Now();
   host_impl_->WillBeginImplFrame(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now));
 
   // TODO(crbug.com/551134): We always request a new frame and a draw for
   // animations that are on the pending tree, but we don't need to do that
   // unless they are waiting for some future time to start.
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
@@ skipping 26 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingCommitToActiveTree) {
   FakeImplTaskRunnerProvider provider(nullptr);
   CreateHostImplWithTaskRunnerProvider(DefaultSettings(), CreateOutputSurface(),
                                        &provider);
   EXPECT_TRUE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   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();
   root->SetBounds(gfx::Size(50, 50));
   root->SetHasRenderSurface(true);
 
-  root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
+  root->AddChild(CreateTestLayerImpl(host_impl_->active_tree(), 2));
   LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
-  AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 10.0, 3, 0);
+  AddAnimatedTransformToElementWithPlayer(child->element_id(), timeline(), 10.0,
+                                          3, 0);
 
   // Set up the property trees so that UpdateDrawProperties will work in
   // CommitComplete below.
   LayerImplList list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, gfx::Size(50, 50), &list);
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FALSE(did_request_next_frame_);
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   host_impl_->CommitComplete();
 
   // Animations on the active tree should be started and ticked, and a new frame
   // should be requested to continue ticking them.
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   // Delete the LayerTreeHostImpl before the TaskRunnerProvider goes away.
   host_impl_ = nullptr;
 }
 
 class MissingTilesLayer : public LayerImpl {
  public:
   MissingTilesLayer(LayerTreeImpl* layer_tree_impl, int id)
-      : LayerImpl(layer_tree_impl, id), has_missing_tiles_(true) {}
+      : LayerImpl(layer_tree_impl, id), has_missing_tiles_(true) {
+    SetElementId(NextTestElementId());
+  }
 
   void set_has_missing_tiles(bool has_missing_tiles) {
     has_missing_tiles_ = has_missing_tiles;
   }
 
   void AppendQuads(RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override {
     append_quads_data->num_missing_tiles += has_missing_tiles_;
   }
 
  private:
   bool has_missing_tiles_;
 };
 
 TEST_F(LayerTreeHostImplTest, AnimationMarksLayerNotReady) {
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   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();
   root->SetBounds(gfx::Size(50, 50));
   root->SetHasRenderSurface(true);
 
   root->AddChild(std::unique_ptr<MissingTilesLayer>(
       new MissingTilesLayer(host_impl_->active_tree(), 2)));
   MissingTilesLayer* child =
       static_cast<MissingTilesLayer*>(root->children()[0]);
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   EXPECT_TRUE(child->was_ever_ready_since_last_transform_animation());
 
   // Add a translate from 6,7 to 8,9.
   TransformOperations start;
   start.AppendTranslate(6.f, 7.f, 0.f);
   TransformOperations end;
   end.AppendTranslate(8.f, 9.f, 0.f);
-  int animation_id = AddAnimatedTransformToLayerWithPlayer(
-      child->id(), timeline(), 4.0, start, end);
+  int animation_id = AddAnimatedTransformToElementWithPlayer(
+      child->element_id(), timeline(), 4.0, start, end);
 
   base::TimeTicks now = base::TimeTicks::Now();
   host_impl_->WillBeginImplFrame(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now));
 
   host_impl_->ActivateAnimations();
   host_impl_->Animate();
 
   EXPECT_FALSE(child->was_ever_ready_since_last_transform_animation());
 
@@ skipping 10 matching lines @@
   child->set_has_missing_tiles(false);
 
   // Child layer has an animating and no missing tiles.
   result = host_impl_->PrepareToDraw(&frame);
   EXPECT_EQ(DRAW_SUCCESS, result);
   EXPECT_TRUE(child->was_ever_ready_since_last_transform_animation());
   host_impl_->DidDrawAllLayers(frame);
 
   // Remove the animation.
   child->set_has_missing_tiles(true);
-  RemoveAnimationFromLayerWithExistingPlayer(child->id(), timeline(),
-                                             animation_id);
+  RemoveAnimationFromElementWithExistingPlayer(child->element_id(), timeline(),
+                                               animation_id);
   child->draw_properties().screen_space_transform_is_animating = false;
 
   // Child layer doesn't have an animation, but was never ready since the last
   // time it animated (and has missing tiles).
   result = host_impl_->PrepareToDraw(&frame);
   EXPECT_EQ(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS, result);
   EXPECT_FALSE(child->was_ever_ready_since_last_transform_animation());
   host_impl_->DidDrawAllLayers(frame);
 
   child->set_has_missing_tiles(false);
@@ skipping 446 matching lines @@
       SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   // Set up two scrolling children of the root, one of which is a scroll parent
   // to the other. Scrolls shouldn't bubbling from the child.
   LayerImpl *parent;
   LayerImpl *child;
   LayerImpl *child_clip;
 
   std::unique_ptr<LayerImpl> scroll_parent_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 6);
+      CreateTestLayerImpl(host_impl_->active_tree(), 6);
   std::unique_ptr<LayerImpl> scroll_parent =
       CreateScrollableLayer(7, gfx::Size(10, 10), scroll_parent_clip.get());
   parent = scroll_parent.get();
   scroll_parent_clip->AddChild(std::move(scroll_parent));
 
   viewport_scroll->AddChild(std::move(scroll_parent_clip));
 
   std::unique_ptr<LayerImpl> scroll_child_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 8);
+      CreateTestLayerImpl(host_impl_->active_tree(), 8);
   std::unique_ptr<LayerImpl> scroll_child =
       CreateScrollableLayer(9, gfx::Size(10, 10), scroll_child_clip.get());
   child = scroll_child.get();
   scroll_child->SetPosition(gfx::PointF(20.f, 20.f));
   scroll_child_clip->AddChild(std::move(scroll_child));
 
   child_clip = scroll_child_clip.get();
   viewport_scroll->AddChild(std::move(scroll_child_clip));
 
   child_clip->test_properties()->scroll_parent = parent;
@@ skipping 905 matching lines @@
   host_impl_->active_tree()->InnerViewportContainerLayer()->SetBounds(
       inner_viewport_size);
   host_impl_->active_tree()->OuterViewportContainerLayer()->SetBounds(
       outer_viewport_size);
   LayerImpl* root_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   std::unique_ptr<SolidColorScrollbarLayerImpl> horiz_scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), horiz_id,
                                            HORIZONTAL, 5, 5, true, true);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_scroll_id);
   child->SetBounds(content_size);
   std::unique_ptr<LayerImpl> child_clip =
-      LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_clip_id);
   child->SetBounds(inner_viewport_size);
 
   horiz_scrollbar->SetScrollLayerId(root_scroll->id());
 
   EXPECT_EQ(300, horiz_scrollbar->clip_layer_length());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollbarRegistration) {
   LayerTreeSettings settings = DefaultSettings();
   settings.scrollbar_animator = LayerTreeSettings::LINEAR_FADE;
@@ skipping 22 matching lines @@
   std::unique_ptr<SolidColorScrollbarLayerImpl> horiz_1_scrollbar =
       SolidColorScrollbarLayerImpl::Create(
           host_impl_->active_tree(), horiz_1_id, HORIZONTAL, 5, 5, true, true);
   std::unique_ptr<SolidColorScrollbarLayerImpl> vert_2_scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), vert_2_id,
                                            VERTICAL, 5, 5, true, true);
   std::unique_ptr<SolidColorScrollbarLayerImpl> horiz_2_scrollbar =
       SolidColorScrollbarLayerImpl::Create(
           host_impl_->active_tree(), horiz_2_id, HORIZONTAL, 5, 5, true, true);
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_scroll_id);
   child->SetBounds(content_size);
   std::unique_ptr<LayerImpl> child_clip =
-      LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_clip_id);
   child->SetBounds(viewport_size);
   LayerImpl* child_ptr = child.get();
   LayerImpl* child_clip_ptr = child_clip.get();
 
   // Check scrollbar registration on the viewport layers.
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
   EXPECT_EQ(nullptr,
             host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
   vert_1_scrollbar->SetScrollLayerId(root_scroll->id());
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
@@ skipping 311 matching lines @@
     PassCopyRequests(&requests);
   }
 
  protected:
   DidDrawCheckLayer(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id),
         will_draw_returns_false_(false),
         will_draw_called_(false),
         append_quads_called_(false),
         did_draw_called_(false) {
+    SetElementId(NextTestElementId());
     SetBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
     draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
   }
 
  private:
   bool will_draw_returns_false_;
   bool will_draw_called_;
   bool append_quads_called_;
   bool did_draw_called_;
@@ skipping 195 matching lines @@
                                int id,
                                bool tile_missing,
                                bool had_incomplete_tile,
                                bool animating,
                                ResourceProvider* resource_provider,
                                scoped_refptr<AnimationTimeline> timeline)
       : DidDrawCheckLayer(tree_impl, id),
         tile_missing_(tile_missing),
         had_incomplete_tile_(had_incomplete_tile) {
     if (animating)
-      AddAnimatedTransformToLayerWithPlayer(this->id(), timeline, 10.0, 3, 0);
+      AddAnimatedTransformToElementWithPlayer(this->element_id(), timeline,
+                                              10.0, 3, 0);
   }
 
   bool tile_missing_;
   bool had_incomplete_tile_;
 };
 
 struct PrepareToDrawSuccessTestCase {
   struct State {
     bool has_missing_tile = false;
     bool has_incomplete_tile = false;
@@ skipping 236 matching lines @@
       host_impl_->SetRequiresHighResToDraw();
 
     SetNeedsRebuildPropertyTrees();
     host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                        resourceless_software_draw);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->SetScrollClipLayer(Layer::INVALID_ID);
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because layer is not scrollable.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
@@ skipping 66 matching lines @@
       LayerTreeImpl* tree_impl,
       const gfx::Size& inner_viewport_size,
       const gfx::Size& outer_viewport_size,
       const gfx::Size& scroll_layer_size) {
     tree_impl->set_top_controls_shrink_blink_size(true);
     tree_impl->set_top_controls_height(top_controls_height_);
     tree_impl->SetCurrentTopControlsShownRatio(1.f);
     tree_impl->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     host_impl_->DidChangeTopControlsPosition();
 
-    std::unique_ptr<LayerImpl> root = LayerImpl::Create(tree_impl, 1);
-    std::unique_ptr<LayerImpl> root_clip = LayerImpl::Create(tree_impl, 2);
-    std::unique_ptr<LayerImpl> page_scale = LayerImpl::Create(tree_impl, 3);
+    std::unique_ptr<LayerImpl> root = CreateTestLayerImpl(tree_impl, 1);
+    std::unique_ptr<LayerImpl> root_clip = CreateTestLayerImpl(tree_impl, 2);
+    std::unique_ptr<LayerImpl> page_scale = CreateTestLayerImpl(tree_impl, 3);
 
-    std::unique_ptr<LayerImpl> outer_scroll = LayerImpl::Create(tree_impl, 4);
-    std::unique_ptr<LayerImpl> outer_clip = LayerImpl::Create(tree_impl, 5);
+    std::unique_ptr<LayerImpl> outer_scroll = CreateTestLayerImpl(tree_impl, 4);
+    std::unique_ptr<LayerImpl> outer_clip = CreateTestLayerImpl(tree_impl, 5);
 
     root_clip->SetBounds(inner_viewport_size);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(outer_viewport_size);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
     root_clip->test_properties()->force_render_surface = true;
     root->test_properties()->is_container_for_fixed_position_layers = true;
     outer_clip->SetBounds(outer_viewport_size);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
@@ skipping 40 matching lines @@
 TEST_F(LayerTreeHostImplTopControlsTest,
     HidingTopControlsExpandsScrollableSize) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(50, 50), gfx::Size(50, 50), gfx::Size(50, 50));
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
 
   // Create a content layer beneath the outer viewport scroll layer.
   int id = host_impl_->OuterViewportScrollLayer()->id();
   host_impl_->OuterViewportScrollLayer()->AddChild(
-      LayerImpl::Create(host_impl_->active_tree(), id + 2));
+      CreateTestLayerImpl(host_impl_->active_tree(), id + 2));
   LayerImpl* content = active_tree->OuterViewportScrollLayer()->children()[0];
   content->SetBounds(gfx::Size(50, 50));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   LayerImpl* inner_container = active_tree->InnerViewportContainerLayer();
   LayerImpl* outer_container = active_tree->OuterViewportContainerLayer();
 
   // The top controls should start off showing so the viewport should be shrunk.
@@ skipping 242 matching lines @@
   DrawFrame();
 
   // Show top controls
   EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   LayerImpl* outer_viewport_scroll_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   int id = outer_viewport_scroll_layer->id();
 
   std::unique_ptr<LayerImpl> child =
-      LayerImpl::Create(host_impl_->active_tree(), id + 2);
+      CreateTestLayerImpl(host_impl_->active_tree(), id + 2);
   std::unique_ptr<LayerImpl> child_clip =
-      LayerImpl::Create(host_impl_->active_tree(), id + 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->test_properties()->is_container_for_fixed_position_layers = true;
 
   // scroll child to limit
   SetScrollOffsetDelta(child.get(), gfx::Vector2dF(0, 100.f));
@@ skipping 455 matching lines @@
   EXPECT_EQ(800, outer_scroll->CurrentScrollOffset().y());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonCompositedRoot) {
   // Test the configuration where a non-composited root layer is embedded in a
   // scrollable outer layer.
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
 
   std::unique_ptr<LayerImpl> content_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   content_layer->SetDrawsContent(true);
   content_layer->SetPosition(gfx::PointF());
   content_layer->SetBounds(contents_size);
 
   std::unique_ptr<LayerImpl> scroll_clip_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), 3);
   scroll_clip_layer->SetBounds(surface_size);
 
   std::unique_ptr<LayerImpl> scroll_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 2);
+      CreateTestLayerImpl(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->AddChild(std::move(content_layer));
   scroll_clip_layer->AddChild(std::move(scroll_layer));
 
   scroll_clip_layer->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(scroll_clip_layer));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(15, 5)).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
             status.main_thread_scrolling_reasons);
 
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root.get());
   host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
   child->test_properties()->double_sided = false;
 
@@ skipping 10 matching lines @@
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
             status.main_thread_scrolling_reasons);
 
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> clip_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), 3);
   std::unique_ptr<LayerImpl> content_layer =
       CreateScrollableLayer(1, surface_size, clip_layer.get());
   content_layer->set_main_thread_scrolling_reasons(
       MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   content_layer->SetScrollClipLayer(Layer::INVALID_ID);
 
   // Note: we can use the same clip layer for both since both calls to
   // CreateScrollableLayer() use the same surface size.
   std::unique_ptr<LayerImpl> scroll_layer =
       CreateScrollableLayer(2, surface_size, clip_layer.get());
@@ skipping 125 matching lines @@
   new_page_scale_matrix.Scale(new_page_scale, new_page_scale);
 
   // Create a normal scrollable root layer and another scrollable child layer.
   LayerImpl* scroll = SetupScrollAndContentsLayers(surface_size);
   scroll->SetDrawsContent(true);
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   LayerImpl* child = scroll->children()[0];
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> scrollable_child_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 6);
+      CreateTestLayerImpl(host_impl_->active_tree(), 6);
   std::unique_ptr<LayerImpl> scrollable_child =
       CreateScrollableLayer(7, surface_size, scrollable_child_clip.get());
   scrollable_child_clip->AddChild(std::move(scrollable_child));
   child->AddChild(std::move(scrollable_child_clip));
   LayerImpl* grand_child = child->children()[0];
   grand_child->SetDrawsContent(true);
 
   // Set new page scale on impl thread by pinching.
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
@@ skipping 63 matching lines @@
   // scale.
   EXPECT_EQ(1.f, host_impl_->active_tree()->page_scale_delta());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // parent layer isn't scrolled.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, content_size, root.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(std::move(grand_child));
 
@@ skipping 35 matching lines @@
     ExpectNone(*scroll_info.get(), child->id());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(20, 20);
   gfx::Size viewport_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 2);
+      CreateTestLayerImpl(host_impl_->active_tree(), 2);
   root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_scrolling->test_properties()->is_container_for_fixed_position_layers =
       true;
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(5, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
@@ skipping 110 matching lines @@
     EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), grand_child->id(),
                                    gfx::Vector2d(0, 4)));
   }
 }
 TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      CreateTestLayerImpl(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   // Make 'root' the clip layer for child: since they have the same sizes the
   // child will have zero max_scroll_offset and scrolls will bubble.
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_scroll.get());
   child->test_properties()->is_container_for_fixed_position_layers = true;
   root_scroll->SetBounds(content_size);
 
@@ skipping 24 matching lines @@
     // Only the root scroll should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
     EXPECT_TRUE(
         ScrollInfoContains(*scroll_info.get(), root_scroll_id, scroll_delta));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 2);
+      CreateTestLayerImpl(host_impl_->active_tree(), 2);
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_clip->test_properties()->force_render_surface = true;
   root_scroll->test_properties()->is_container_for_fixed_position_layers = true;
   root_clip->AddChild(std::move(root_scroll));
   root_ptr->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 3,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   host_impl_->active_tree()->ClearLayers();
   std::unique_ptr<LayerImpl> root_ptr2 =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      CreateTestLayerImpl(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip2 =
-      LayerImpl::Create(host_impl_->active_tree(), 5);
+      CreateTestLayerImpl(host_impl_->active_tree(), 5);
   std::unique_ptr<LayerImpl> root_scroll2 =
       CreateScrollableLayer(6, surface_size, root_clip2.get());
   root_scroll2->test_properties()->is_container_for_fixed_position_layers =
       true;
   root_clip2->AddChild(std::move(root_scroll2));
   root_clip2->test_properties()->force_render_surface = true;
   root_ptr2->AddChild(std::move(root_clip2));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr2));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 4, 6,
                                                       Layer::INVALID_ID);
@@ skipping 55 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   int child_clip_layer_id = 6;
   int child_layer_id = 7;
   float child_layer_angle = -20.f;
 
   // Create a child layer that is rotated to a non-axis-aligned angle.
   std::unique_ptr<LayerImpl> clip_layer =
-      LayerImpl::Create(host_impl_->active_tree(), child_clip_layer_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_clip_layer_id);
   std::unique_ptr<LayerImpl> child = CreateScrollableLayer(
       child_layer_id, scroll_layer->bounds(), clip_layer.get());
   gfx::Transform rotate_transform;
   rotate_transform.Translate(-50.0, -50.0);
   rotate_transform.Rotate(child_layer_angle);
   rotate_transform.Translate(50.0, 50.0);
   clip_layer->SetTransform(rotate_transform);
 
   // Only allow vertical scrolling.
   clip_layer->SetBounds(
@@ skipping 64 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ScrollPerspectiveTransformedLayer) {
   // When scrolling an element with perspective, the distance scrolled
   // depends on the point at which the scroll begins.
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   int child_clip_layer_id = 6;
   int child_layer_id = 7;
 
   // Create a child layer that is rotated on its x axis, with perspective.
   std::unique_ptr<LayerImpl> clip_layer =
-      LayerImpl::Create(host_impl_->active_tree(), child_clip_layer_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), child_clip_layer_id);
   std::unique_ptr<LayerImpl> child = CreateScrollableLayer(
       child_layer_id, scroll_layer->bounds(), clip_layer.get());
   LayerImpl* child_ptr = child.get();
   gfx::Transform perspective_transform;
   perspective_transform.Translate(-50.0, -50.0);
   perspective_transform.ApplyPerspectiveDepth(20);
   perspective_transform.RotateAboutXAxis(45);
   perspective_transform.Translate(50.0, 50.0);
   clip_layer->SetTransform(perspective_transform);
 
@@ skipping 450 matching lines @@
   host_impl_->ScrollEnd(EndState().get());
 }
 
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) {
   // Scroll child layers beyond their maximum scroll range and make sure root
   // overscroll does not accumulate.
   InputHandlerScrollResult scroll_result;
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      CreateTestLayerImpl(host_impl_->active_tree(), 4);
   root_clip->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> root =
       CreateScrollableLayer(1, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
@@ skipping 266 matching lines @@
   bool quads_appended_;
   gfx::Rect quad_rect_;
   gfx::Rect opaque_content_rect_;
   gfx::Rect quad_visible_rect_;
   ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   {
     std::unique_ptr<LayerImpl> root =
-        LayerImpl::Create(host_impl_->active_tree(), 1);
+        CreateTestLayerImpl(host_impl_->active_tree(), 1);
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(false);
     root->test_properties()->force_render_surface = true;
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
@@ skipping 247 matching lines @@
     if (software) {
       return FakeOutputSurface::CreateSoftware(
           base::WrapUnique(new SoftwareOutputDevice()));
     }
     return FakeOutputSurface::Create3d();
   }
 
   void SetupActiveTreeLayers() {
     host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
     host_impl_->active_tree()->SetRootLayer(
-        LayerImpl::Create(host_impl_->active_tree(), 1));
+        CreateTestLayerImpl(host_impl_->active_tree(), 1));
     host_impl_->active_tree()
         ->root_layer()
         ->test_properties()
         ->force_render_surface = true;
     host_impl_->active_tree()->root_layer()->AddChild(
         BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                      2,
                                      host_impl_->resource_provider()));
     child_ = static_cast<BlendStateCheckLayer*>(
         host_impl_->active_tree()->root_layer()->children()[0]);
@@ skipping 270 matching lines @@
   EXPECT_SCOPED(TestLayerIsLargerThanViewportWithOnDraw());
 }
 
 class FakeDrawableLayerImpl: public LayerImpl {
  public:
   static std::unique_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return base::WrapUnique(new FakeDrawableLayerImpl(tree_impl, id));
   }
  protected:
   FakeDrawableLayerImpl(LayerTreeImpl* tree_impl, int id)
-      : LayerImpl(tree_impl, id) {}
+      : LayerImpl(tree_impl, id) {
+    SetElementId(NextTestElementId());
+  }
 };
 
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
@@ skipping 374 matching lines @@
     |  |           |     |
     |  +-----------+     |
     |                    |
     |                    |
     +--------------------+
 
     Layers 1, 2 have render surfaces
   */
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
+  root->SetElementId(NextTestElementId());
+
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(my_host_impl->active_tree(), 2);
+  child->SetElementId(NextTestElementId());
+
   std::unique_ptr<LayerImpl> grand_child =
       FakeLayerWithQuads::Create(my_host_impl->active_tree(), 3);
 
   gfx::Rect root_rect(0, 0, 100, 100);
   gfx::Rect child_rect(10, 10, 50, 50);
   gfx::Rect grand_child_rect(5, 5, 150, 150);
 
   root->test_properties()->force_render_surface = true;
   root->SetPosition(gfx::PointF(root_rect.origin()));
   root->SetBounds(root_rect.size());
@@ skipping 82 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context)));
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   std::unique_ptr<LayerImpl> root_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root_layer->SetBounds(gfx::Size(10, 10));
   root_layer->test_properties()->force_render_surface = true;
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
+  video_layer->SetElementId(NextTestElementId());
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->AddChild(std::move(video_layer));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
 
   EXPECT_GT(context3d->NumTextures(), 0u);
 
   // Kill the layer tree.
   host_impl_->active_tree()->SetRootLayer(
-      LayerImpl::Create(host_impl_->active_tree(), 100));
+      CreateTestLayerImpl(host_impl_->active_tree(), 100));
   // There should be no textures left in use after.
   EXPECT_EQ(0u, context3d->NumTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(useProgram, void(GLuint program));
   MOCK_METHOD4(drawElements, void(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
                                   GLintptr offset));
 };
 
 TEST_F(LayerTreeHostImplTest, HasTransparentBackground) {
   std::unique_ptr<MockDrawQuadsToFillScreenContext> mock_context_owned(
       new MockDrawQuadsToFillScreenContext);
   MockDrawQuadsToFillScreenContext* mock_context = mock_context_owned.get();
 
   // Run test case
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = false;
   CreateHostImpl(settings,
                  FakeOutputSurface::Create3d(std::move(mock_context_owned)));
-  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+  SetupRootLayerImpl(CreateTestLayerImpl(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->set_background_color(SK_ColorWHITE);
 
   // Verify one quad is drawn when transparent background set is not set.
   host_impl_->active_tree()->set_has_transparent_background(false);
   EXPECT_CALL(*mock_context, useProgram(_))
       .Times(1);
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _))
       .Times(1);
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
@@ skipping 50 matching lines @@
 
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
     EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
+  root->SetElementId(NextTestElementId());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->test_properties()->force_render_surface = true;
 
   // Child layer is in the bottom right corner.
   std::unique_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
+  child->SetElementId(NextTestElementId());
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
   root->AddChild(std::move(child));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   DrawFrameAndTestDamage(full_frame_damage);
@@ skipping 30 matching lines @@
   gfx::Size device_viewport_size =
       gfx::ScaleToCeiledSize(root_size, device_scale_factor);
   host_impl_->SetViewportSize(device_viewport_size);
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f / 16.f,
                                                           16.f);
 
   std::unique_ptr<LayerImpl> scoped_root =
-      LayerImpl::Create(host_impl_->pending_tree(), 1);
+      CreateTestLayerImpl(host_impl_->pending_tree(), 1);
   LayerImpl* root = scoped_root.get();
   root->test_properties()->force_render_surface = true;
 
   host_impl_->pending_tree()->SetRootLayer(std::move(scoped_root));
 
   std::unique_ptr<LayerImpl> scoped_scrolling_layer =
-      LayerImpl::Create(host_impl_->pending_tree(), 2);
+      CreateTestLayerImpl(host_impl_->pending_tree(), 2);
   LayerImpl* scrolling_layer = scoped_scrolling_layer.get();
   root->AddChild(std::move(scoped_scrolling_layer));
 
   gfx::Size content_layer_bounds(100000, 100);
   scoped_refptr<FakeRasterSource> raster_source(
       FakeRasterSource::CreateFilled(content_layer_bounds));
 
   std::unique_ptr<FakePictureLayerImpl> scoped_content_layer =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_->pending_tree(),
                                                    3, raster_source);
@@ skipping 126 matching lines @@
   const gfx::Transform external_transform;
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   // SolidColorLayerImpl will be drawn.
   std::unique_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
+  root_layer->SetElementId(NextTestElementId());
 
   // VideoLayerImpl will not be drawn.
   FakeVideoFrameProvider provider;
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
+  video_layer->SetElementId(NextTestElementId());
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->AddChild(std::move(video_layer));
   SetupRootLayerImpl(std::move(root_layer));
 
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
 
   EXPECT_EQ(1u, last_on_draw_frame_->will_draw_layers.size());
   EXPECT_EQ(host_impl_->active_tree()->root_layer(),
@@ skipping 161 matching lines @@
 void ShutdownReleasesContext_Callback(
     std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostImplTest, ShutdownReleasesContext) {
   scoped_refptr<TestContextProvider> context_provider =
       TestContextProvider::Create();
 
   CreateHostImpl(DefaultSettings(),
                  FakeOutputSurface::Create3d(context_provider));
 
-  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+  SetupRootLayerImpl(CreateTestLayerImpl(host_impl_->active_tree(), 1));
 
   std::vector<std::unique_ptr<CopyOutputRequest>> requests;
   requests.push_back(CopyOutputRequest::CreateRequest(
       base::Bind(&ShutdownReleasesContext_Callback)));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->PassCopyRequests(&requests);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
@@ skipping 12 matching lines @@
   EXPECT_TRUE(context_provider->HasOneRef());
   EXPECT_EQ(0u, context_provider->TestContext3d()->NumTextures());
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldNotBubble) {
   // When flinging via touch, only the child should scroll (we should not
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      CreateTestLayerImpl(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   root_scroll->test_properties()->is_container_for_fixed_position_layers = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
   root_scroll->AddChild(std::move(child));
   int root_id = root_scroll->id();
@@ skipping 30 matching lines @@
     ASSERT_EQ(1u, scroll_info->scrolls.size());
     ExpectNone(*scroll_info.get(), root_id);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldContinueScrollingCurrentLayer) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      CreateTestLayerImpl(host_impl_->active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(2, surface_size, root.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(4, surface_size, root.get());
   grand_child->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child->id(),
                                                      gfx::ScrollOffset(0, 2));
@@ skipping 68 matching lines @@
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
     host_impl_->ScrollEnd(EndState().get());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, WheelFlingShouldntBubble) {
   // When flinging via wheel, we shouldn't bubble.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      CreateTestLayerImpl(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   int root_scroll_id = root_scroll->id();
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
   root_scroll->AddChild(std::move(child));
   root_clip->AddChild(std::move(root_scroll));
 
@@ skipping 36 matching lines @@
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
   scroll_layer->SetDrawsContent(true);
 
   int page_scale_layer_id = 5;
   LayerImpl* page_scale_layer =
       host_impl_->active_tree()->LayerById(page_scale_layer_id);
 
   int occluder_layer_id = 6;
   std::unique_ptr<LayerImpl> occluder_layer =
-      LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF());
 
   // The parent of the occluder is *above* the scroller.
   page_scale_layer->AddChild(std::move(occluder_layer));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
@@ skipping 11 matching lines @@
   gfx::Size content_size(100, 100);
   SetupScrollAndContentsLayers(content_size);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
   scroll_layer->SetDrawsContent(true);
 
   int occluder_layer_id = 6;
   std::unique_ptr<LayerImpl> occluder_layer =
-      LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF(-10.f, -10.f));
 
   int child_scroll_clip_layer_id = 7;
-  std::unique_ptr<LayerImpl> child_scroll_clip =
-      LayerImpl::Create(host_impl_->active_tree(), child_scroll_clip_layer_id);
+  std::unique_ptr<LayerImpl> child_scroll_clip = CreateTestLayerImpl(
+      host_impl_->active_tree(), child_scroll_clip_layer_id);
 
   int child_scroll_layer_id = 8;
   std::unique_ptr<LayerImpl> child_scroll = CreateScrollableLayer(
       child_scroll_layer_id, content_size, child_scroll_clip.get());
 
   child_scroll->SetPosition(gfx::PointF(10.f, 10.f));
 
   child_scroll->AddChild(std::move(occluder_layer));
   child_scroll_clip->AddChild(std::move(child_scroll));
   scroll_layer->AddChild(std::move(child_scroll_clip));
@@ skipping 47 matching lines @@
   SetupScrollAndContentsLayers(content_size);
 
   LayerImpl* root = host_impl_->active_tree()->LayerById(1);
   LayerImpl* root_scroll_layer = host_impl_->active_tree()->LayerById(2);
 
   std::unique_ptr<LayerImpl> invisible_scroll_layer =
       CreateScrollableLayer(7, content_size, root);
   invisible_scroll_layer->SetDrawsContent(false);
 
   std::unique_ptr<LayerImpl> child_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 8);
+      CreateTestLayerImpl(host_impl_->active_tree(), 8);
   child_layer->SetDrawsContent(false);
 
   std::unique_ptr<LayerImpl> grand_child_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 9);
+      CreateTestLayerImpl(host_impl_->active_tree(), 9);
   grand_child_layer->SetDrawsContent(true);
   grand_child_layer->SetBounds(content_size);
   // Move the grand child so it's not hit by our test point.
   grand_child_layer->SetPosition(gfx::PointF(10.f, 10.f));
 
   child_layer->AddChild(std::move(grand_child_layer));
   invisible_scroll_layer->AddChild(std::move(child_layer));
   root_scroll_layer->AddChild(std::move(invisible_scroll_layer));
 
   SetNeedsRebuildPropertyTrees();
@@ skipping 18 matching lines @@
   SetupScrollAndContentsLayers(content_size);
 
   LayerImpl* root = host_impl_->active_tree()->LayerById(1);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
 
   int scroll_child_id = 6;
   std::unique_ptr<LayerImpl> scroll_child =
-      LayerImpl::Create(host_impl_->active_tree(), scroll_child_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), scroll_child_id);
   scroll_child->SetDrawsContent(true);
   scroll_child->SetBounds(content_size);
   // Move the scroll child so it's not hit by our test point.
   scroll_child->SetPosition(gfx::PointF(10.f, 10.f));
 
   int invisible_scroll_layer_id = 7;
   std::unique_ptr<LayerImpl> invisible_scroll =
       CreateScrollableLayer(invisible_scroll_layer_id, content_size, root);
   invisible_scroll->SetDrawsContent(false);
 
   int container_id = 8;
   std::unique_ptr<LayerImpl> container =
-      LayerImpl::Create(host_impl_->active_tree(), container_id);
+      CreateTestLayerImpl(host_impl_->active_tree(), container_id);
 
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child.get());
   invisible_scroll->test_properties()->scroll_children.reset(
       scroll_children.release());
 
   scroll_child->test_properties()->scroll_parent = invisible_scroll.get();
 
   container->AddChild(std::move(invisible_scroll));
@@ skipping 13 matching lines @@
                 .thread);
 
   EXPECT_EQ(7, host_impl_->CurrentlyScrollingLayer()->id());
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
+  root->SetElementId(NextTestElementId());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
 
@@ skipping 20 matching lines @@
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_EQ(1u, metadata_latency_after.size());
   EXPECT_TRUE(metadata_latency_after[0].FindLatency(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
 }
 
 TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
   int root_layer_id = 1;
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
+  root->SetElementId(NextTestElementId());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Ensure the default frame selection bounds are empty.
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
@@ skipping 635 matching lines @@
                                   const gfx::Size& outer_viewport,
                                   const gfx::Size& inner_viewport) {
     LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
     const int kOuterViewportClipLayerId = 6;
     const int kOuterViewportScrollLayerId = 7;
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
 
     std::unique_ptr<LayerImpl> inner_scroll =
-        LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->test_properties()->is_container_for_fixed_position_layers =
         true;
     inner_scroll->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(inner_scroll->id(),
                                                        gfx::ScrollOffset());
 
     std::unique_ptr<LayerImpl> inner_clip =
-        LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(inner_viewport);
 
     std::unique_ptr<LayerImpl> page_scale =
-        LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(outer_viewport);
     inner_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> outer_clip =
-        LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(outer_viewport);
     outer_clip->test_properties()->is_container_for_fixed_position_layers =
         true;
 
     std::unique_ptr<LayerImpl> outer_scroll =
-        LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
+        CreateTestLayerImpl(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(outer_scroll->id(),
                                                        gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
-    std::unique_ptr<LayerImpl> contents = LayerImpl::Create(layer_tree_impl, 8);
+    std::unique_ptr<LayerImpl> contents =
+        CreateTestLayerImpl(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(std::move(contents));
     outer_clip->AddChild(std::move(outer_scroll));
     inner_scroll->AddChild(std::move(outer_clip));
     page_scale->AddChild(std::move(inner_scroll));
     inner_clip->AddChild(std::move(page_scale));
 
@@ skipping 339 matching lines @@
   external_transform.Translate(20, 20);
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       external_transform, layer->draw_properties().target_space_transform);
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) {
-  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+  SetupRootLayerImpl(CreateTestLayerImpl(host_impl_->active_tree(), 1));
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform transform_for_tile_priority;
   const gfx::Transform draw_transform;
   const gfx::Rect viewport_for_tile_priority1(viewport_size);
   const gfx::Rect viewport_for_tile_priority2(50, 50);
   const gfx::Rect draw_viewport(viewport_size);
   const gfx::Rect clip(viewport_size);
@@ skipping 10 matching lines @@
   did_request_redraw_ = false;
   host_impl_->SetExternalTilePriorityConstraints(viewport_for_tile_priority2,
                                                  transform_for_tile_priority);
   EXPECT_TRUE(did_request_redraw_);
   host_impl_->OnDraw(draw_transform, draw_viewport, clip,
                      resourceless_software_draw);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
 TEST_F(LayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) {
-  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+  SetupRootLayerImpl(CreateTestLayerImpl(host_impl_->active_tree(), 1));
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform draw_transform;
   const gfx::Rect draw_viewport1(viewport_size);
   const gfx::Rect draw_viewport2(50, 50);
   const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
@@ skipping 20 matching lines @@
 
 class ResourcelessSoftwareLayerTreeHostImplTest : public LayerTreeHostImplTest {
  protected:
   std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     return FakeOutputSurface::Create3dWithResourcelessSoftwareSupport();
   }
 };
 
 TEST_F(ResourcelessSoftwareLayerTreeHostImplTest,
        ResourcelessSoftwareSetNeedsRedraw) {
-  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+  SetupRootLayerImpl(CreateTestLayerImpl(host_impl_->active_tree(), 1));
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform draw_transform;
   const gfx::Rect draw_viewport(viewport_size);
   const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
   // Clear any damage.
@@ skipping 56 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ExternalTileConstraintReflectedInPendingTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
   const gfx::Size layer_size(100, 100);
   host_impl_->SetViewportSize(layer_size);
   bool update_lcd_text = false;
 
   // Set up active and pending tree.
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetRootLayer(
-      LayerImpl::Create(host_impl_->pending_tree(), 1));
+      CreateTestLayerImpl(host_impl_->pending_tree(), 1));
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
   host_impl_->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   host_impl_->ActivateSyncTree();
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->UpdateDrawProperties(update_lcd_text);
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
@@ skipping 82 matching lines @@
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
   LayerImpl* content_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer()->children()[0];
-  content_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
+  content_layer->AddChild(CreateTestLayerImpl(host_impl_->active_tree(), 100));
   LayerImpl* test_layer = host_impl_->active_tree()->LayerById(100);
   test_layer->test_properties()->force_render_surface = true;
   test_layer->SetDrawsContent(true);
   test_layer->SetBounds(layer_size);
   gfx::Transform perspective_transform;
   perspective_transform.ApplyPerspectiveDepth(2);
   test_layer->SetTransform(perspective_transform);
 
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
@@ skipping 122 matching lines @@
       host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 50)).thread);
 
   LayerImpl* scrolling_layer = host_impl_->CurrentlyScrollingLayer();
 
   begin_frame_args.frame_time = start_time;
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_TRUE(host_impl_->animation_host()->HasAnyAnimationTargetingProperty(
-      scrolling_layer->id(), TargetProperty::SCROLL_OFFSET));
+      scrolling_layer->element_id(), TargetProperty::SCROLL_OFFSET));
 
   EXPECT_EQ(gfx::ScrollOffset(), scrolling_layer->CurrentScrollOffset());
   host_impl_->DidFinishImplFrame();
 
   begin_frame_args.frame_time =
       start_time + base::TimeDelta::FromMilliseconds(50);
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
@@ skipping 50 matching lines @@
       host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 100)).thread);
 
   LayerImpl* scrolling_layer = host_impl_->CurrentlyScrollingLayer();
 
   begin_frame_args.frame_time = start_time;
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_TRUE(host_impl_->animation_host()->HasAnyAnimationTargetingProperty(
-      scrolling_layer->id(), TargetProperty::SCROLL_OFFSET));
+      scrolling_layer->element_id(), TargetProperty::SCROLL_OFFSET));
 
   EXPECT_EQ(gfx::ScrollOffset(), scrolling_layer->CurrentScrollOffset());
   host_impl_->DidFinishImplFrame();
 
   begin_frame_args.frame_time =
       start_time + base::TimeDelta::FromMilliseconds(50);
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
@@ skipping 854 matching lines @@
           page_scale_layer->transform_tree_index());
   EXPECT_EQ(active_tree_node->data.post_local_scale_factor, 2.f);
 }
 
 TEST_F(LayerTreeHostImplTest, SubLayerScaleForNodeInSubtreeOfPageScaleLayer) {
   // Checks that the sublayer scale of a transform node in the subtree of the
   // page scale layer is updated without a property tree rebuild.
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 3.f);
   CreateScrollAndContentsLayers(host_impl_->active_tree(), gfx::Size(100, 100));
   LayerImpl* page_scale_layer = host_impl_->active_tree()->PageScaleLayer();
-  page_scale_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
+  page_scale_layer->AddChild(
+      CreateTestLayerImpl(host_impl_->active_tree(), 100));
 
   LayerImpl* in_subtree_of_page_scale_layer =
       host_impl_->active_tree()->LayerById(100);
   in_subtree_of_page_scale_layer->test_properties()->force_render_surface =
       true;
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   DrawFrame();
   TransformNode* node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
@@ skipping 95 matching lines @@
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateSoftware(
       base::WrapUnique(new SoftwareOutputDevice));
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc