Change cc::ElementId to be a uint64_t

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 321 matching lines @@
 
     std::unique_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(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);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
-    inner_scroll->SetElementId(
-        LayerIdToElementIdForTesting(inner_scroll->id()));
+    ElementId element_id;
+    element_id.id = inner_scroll->id();
+    inner_scroll->SetElementId(element_id);
     inner_scroll->SetBounds(content_size);
     inner_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(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);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
-    outer_scroll->SetElementId(
-        LayerIdToElementIdForTesting(outer_scroll->id()));
+    element_id.id = outer_scroll->id();
+    outer_scroll->SetElementId(element_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);
     contents->SetDrawsContent(true);
@@ skipping 59 matching lines @@
   }
 
   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);
     layer->SetScrollClipLayer(clip_layer->id());
-    layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
+    ElementId element_id;
+    element_id.id = layer->id();
+    layer->SetElementId(element_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;
     scroll_state_data.position_x = point.x();
@@ skipping 273 matching lines @@
 
   auto root_clip_owned = LayerImpl::Create(host_impl_->active_tree(), 2);
   auto* root_clip = root_clip_owned.get();
   auto root_owned = LayerImpl::Create(host_impl_->active_tree(), 1);
   auto* root = root_owned.get();
 
   root_clip->SetBounds(gfx::Size(10, 10));
   root_clip->test_properties()->AddChild(std::move(root_owned));
   root->SetBounds(gfx::Size(110, 110));
   root->SetScrollClipLayer(root_clip->id());
-  root->SetElementId(LayerIdToElementIdForTesting(root->id()));
+  ElementId element_id;
+  element_id.id = root->id();
+  root->SetElementId(element_id);
   root->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(root->id(), scroll_offset);
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_clip_owned));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info;
 
   root->ScrollBy(scroll_delta);
   scroll_info = host_impl_->ProcessScrollDeltas();
@@ skipping 22 matching lines @@
       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);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(gfx::Size(100, 100));
 
   child->SetScrollClipLayer(child_clip->id());
-  child->SetElementId(LayerIdToElementIdForTesting(child->id()));
+  ElementId element_id;
+  element_id.id = child->id();
+  child->SetElementId(element_id);
   child->SetBounds(gfx::Size(100, 400));
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
 
   child_clip->test_properties()->AddChild(std::move(child));
   outer_viewport_scroll_layer->test_properties()->AddChild(
       std::move(child_clip));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   base::HistogramTester histogram_tester;
@@ skipping 302 matching lines @@
   root->SetBounds(content_size);
   root->SetPosition(gfx::PointF());
 
   std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 2);
   clip->SetBounds(content_size);
   clip->SetPosition(gfx::PointF());
 
   std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 3);
   scroll->SetBounds(scroll_content_size);
   scroll->SetScrollClipLayer(clip->id());
-  scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+  ElementId element_id;
+  element_id.id = scroll->id();
+  scroll->SetElementId(element_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->SetScrollElementId(scroll->element_id());
   scrollbar->SetDrawsContent(true);
   scrollbar->test_properties()->opacity = 1.f;
@@ skipping 51 matching lines @@
   root->SetBounds(content_size);
   root->SetPosition(gfx::PointF());
 
   std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 2);
   clip->SetBounds(content_size);
   clip->SetPosition(gfx::PointF());
 
   std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 3);
   scroll->SetBounds(scroll_content_size);
   scroll->SetScrollClipLayer(clip->id());
-  scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+  ElementId element_id;
+  element_id.id = scroll->id();
+  scroll->SetElementId(element_id);
   scroll->SetDrawsContent(true);
 
   std::unique_ptr<SolidColorScrollbarLayerImpl> drawn_scrollbar =
       SolidColorScrollbarLayerImpl::Create(layer_tree_impl, 4, VERTICAL, 10, 0,
                                            false, true);
   drawn_scrollbar->SetBounds(scrollbar_size);
   drawn_scrollbar->SetPosition(gfx::PointF(345, 0));
   drawn_scrollbar->SetScrollElementId(scroll->element_id());
   drawn_scrollbar->SetDrawsContent(true);
   drawn_scrollbar->test_properties()->opacity = 1.f;
@@ skipping 224 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->test_properties()->children.size());
   LayerImpl* overflow = scroll_layer->test_properties()->children[0];
   overflow->SetBounds(overflow_size);
   overflow->SetScrollClipLayer(
       scroll_layer->test_properties()->parent->test_properties()->parent->id());
-  overflow->SetElementId(LayerIdToElementIdForTesting(overflow->id()));
+  ElementId element_id;
+  element_id.id = overflow->id();
+  overflow->SetElementId(element_id);
   overflow->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(overflow->id(),
                                                      gfx::ScrollOffset());
   overflow->SetPosition(gfx::PointF());
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
@@ skipping 1942 matching lines @@
   // Scrolling the viewport should result in a scrollbar animation update.
   animation_task_ = base::Closure();
   host_impl_->ScrollBegin(BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(10, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
 
   // Check scrollbar registration on a sublayer.
   child->SetScrollClipLayer(child_clip->id());
-  child->SetElementId(LayerIdToElementIdForTesting(child->id()));
+  ElementId element_id;
+  element_id.id = child->id();
+  child->SetElementId(element_id);
   ElementId child_scroll_element_id = child->element_id();
   child_clip->test_properties()->AddChild(std::move(child));
   root_scroll->test_properties()->AddChild(std::move(child_clip));
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(child_scroll_element_id).size());
   EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
                          child_scroll_element_id));
   vert_2_scrollbar->SetScrollElementId(child_scroll_element_id);
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(child_scroll_element_id).size());
   EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
       child_scroll_element_id));
@@ skipping 555 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) {
-      this->SetElementId(LayerIdToElementIdForTesting(id));
+      ElementId element_id;
+      element_id.id = id;
+      this->SetElementId(element_id);
       AddAnimatedTransformToElementWithPlayer(this->element_id(), timeline,
                                               10.0, 3, 0);
     }
   }
 
   bool tile_missing_;
   bool had_incomplete_tile_;
 };
 
 struct PrepareToDrawSuccessTestCase {
@@ skipping 295 matching lines @@
 
     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> outer_scroll = LayerImpl::Create(tree_impl, 4);
     std::unique_ptr<LayerImpl> outer_clip = LayerImpl::Create(tree_impl, 5);
 
     root_clip->SetBounds(inner_viewport_size);
     root->SetScrollClipLayer(root_clip->id());
-    root->SetElementId(LayerIdToElementIdForTesting(root->id()));
+    ElementId element_id;
+    element_id.id = root->id();
+    root->SetElementId(element_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());
-    outer_scroll->SetElementId(
-        LayerIdToElementIdForTesting(outer_scroll->id()));
+    element_id.id = outer_scroll->id();
+    outer_scroll->SetElementId(element_id);
     outer_scroll->SetBounds(scroll_layer_size);
     outer_scroll->SetPosition(gfx::PointF());
     outer_scroll->SetDrawsContent(false);
     outer_scroll->test_properties()->is_container_for_fixed_position_layers =
         true;
 
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
 
@@ skipping 330 matching lines @@
       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);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
-  child->SetElementId(LayerIdToElementIdForTesting(child->id()));
+  ElementId element_id;
+  element_id.id = child->id();
+  child->SetElementId(element_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));
   child_clip->test_properties()->AddChild(std::move(child));
   outer_viewport_scroll_layer->test_properties()->AddChild(
       std::move(child_clip));
@@ skipping 528 matching lines @@
   content_layer->SetDrawsContent(true);
   content_layer->SetPosition(gfx::PointF());
   content_layer->SetBounds(contents_size);
 
   LayerImpl* scroll_clip_layer =
       CreateBasicVirtualViewportLayers(surface_size, surface_size);
 
   std::unique_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 12);
   scroll_layer->SetScrollClipLayer(scroll_clip_layer->id());
-  scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
+  ElementId element_id;
+  element_id.id = scroll_layer->id();
+  scroll_layer->SetElementId(element_id);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->test_properties()->AddChild(std::move(content_layer));
   scroll_clip_layer->test_properties()->AddChild(std::move(scroll_layer));
 
   scroll_clip_layer->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
@@ skipping 1611 matching lines @@
   // passing through the outer viewport still scroll correctly and affect
   // browser controls.
   {
     std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 10);
     clip->SetBounds(viewport_size);
     clip->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 11);
     scroll->SetBounds(gfx::Size(400, 400));
     scroll->SetScrollClipLayer(clip->id());
-    scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+    ElementId element_id;
+    element_id.id = scroll->id();
+    scroll->SetElementId(element_id);
     scroll->SetDrawsContent(true);
 
     scroll_layer = scroll.get();
 
     clip->test_properties()->AddChild(std::move(scroll));
     inner_scroll_layer->test_properties()->AddChild(std::move(clip));
 
     // Move the outer viewport layer away so that scrolls won't target it.
     host_impl_->active_tree()->OuterViewportContainerLayer()->SetPosition(
         gfx::PointF(400, 400));
@@ skipping 70 matching lines @@
   // with another scrolling div inside it. Set the outer "div" to be the outer
   // viewport.
   {
     std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 10);
     clip->SetBounds(content_size);
     clip->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 11);
     scroll->SetBounds(gfx::Size(400, 400));
     scroll->SetScrollClipLayer(clip->id());
-    scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+    ElementId element_id;
+    element_id.id = scroll->id();
+    scroll->SetElementId(element_id);
     scroll->SetDrawsContent(true);
 
     std::unique_ptr<LayerImpl> clip2 = LayerImpl::Create(layer_tree_impl, 12);
     clip2->SetBounds(gfx::Size(300, 300));
     clip2->SetPosition(gfx::PointF());
     clip2->SetDrawsContent(true);
 
     std::unique_ptr<LayerImpl> scroll2 = LayerImpl::Create(layer_tree_impl, 13);
     scroll2->SetBounds(gfx::Size(500, 500));
     scroll2->SetScrollClipLayer(clip2->id());
-    scroll2->SetElementId(LayerIdToElementIdForTesting(scroll2->id()));
+    element_id.id = scroll2->id();
+    scroll2->SetElementId(element_id);
     scroll2->SetDrawsContent(true);
 
     scroll_layer = scroll.get();
     child_scroll_layer = scroll2.get();
 
     clip2->test_properties()->AddChild(std::move(scroll2));
     scroll->test_properties()->AddChild(std::move(clip2));
 
     clip->test_properties()->AddChild(std::move(scroll));
     content_layer->test_properties()->AddChild(std::move(clip));
@@ skipping 101 matching lines @@
   // set as the outer viewport. Add a sibling scrolling layer that isn't a child
   // of the outer viewport scroll layer.
   {
     std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 10);
     clip->SetBounds(content_size);
     clip->SetPosition(gfx::PointF(100, 100));
 
     std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 11);
     scroll->SetBounds(gfx::Size(1200, 1200));
     scroll->SetScrollClipLayer(clip->id());
-    scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+    ElementId element_id;
+    element_id.id = scroll->id();
+    scroll->SetElementId(element_id);
     scroll->SetDrawsContent(true);
 
     outer_scroll_layer = scroll.get();
 
     clip->test_properties()->AddChild(std::move(scroll));
     content_layer->test_properties()->AddChild(std::move(clip));
 
     // Create the non-descendant.
     std::unique_ptr<LayerImpl> clip2 = LayerImpl::Create(layer_tree_impl, 14);
     clip2->SetBounds(gfx::Size(600, 600));
     clip2->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> scroll2 = LayerImpl::Create(layer_tree_impl, 15);
     scroll2->SetBounds(gfx::Size(1200, 1200));
     scroll2->SetScrollClipLayer(clip2->id());
-    scroll2->SetElementId(LayerIdToElementIdForTesting(scroll2->id()));
+    element_id.id = scroll2->id();
+    scroll2->SetElementId(element_id);
     scroll2->SetDrawsContent(true);
 
     sibling_scroll_layer = scroll2.get();
 
     clip2->test_properties()->AddChild(std::move(scroll2));
     content_layer->test_properties()->AddChild(std::move(clip2));
 
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, layer_tree_impl->PageScaleLayer()->id(),
         inner_scroll_layer->id(), outer_scroll_layer->id());
@@ skipping 1317 matching lines @@
                                                    3, raster_source);
   LayerImpl* content_layer = scoped_content_layer.get();
   scrolling_layer->test_properties()->AddChild(std::move(scoped_content_layer));
   content_layer->SetBounds(content_layer_bounds);
   content_layer->SetDrawsContent(true);
 
   root->SetBounds(root_size);
 
   gfx::ScrollOffset scroll_offset(100000, 0);
   scrolling_layer->SetScrollClipLayer(root->id());
-  scrolling_layer->SetElementId(
-      LayerIdToElementIdForTesting(scrolling_layer->id()));
+  ElementId element_id;
+  element_id.id = scrolling_layer->id();
+  scrolling_layer->SetElementId(element_id);
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
 
   scrolling_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scrolling_layer->id(),
                                                      scroll_offset);
   host_impl_->ActivateSyncTree();
 
   bool update_lcd_text = false;
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
@@ skipping 1433 matching lines @@
   // set its scroll layer as the outer viewport. This simulates setting a
   // scrolling element as the root scroller on the page.
   {
     std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 10);
     clip->SetBounds(root_layer_size);
     clip->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 11);
     scroll->SetBounds(scroll_content_size);
     scroll->SetScrollClipLayer(clip->id());
-    scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
+    ElementId element_id;
+    element_id.id = scroll->id();
+    scroll->SetElementId(element_id);
     scroll->SetDrawsContent(true);
 
     scroll_layer = scroll.get();
 
     clip->test_properties()->AddChild(std::move(scroll));
     outer_scroll->test_properties()->AddChild(std::move(clip));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, layer_tree_impl->PageScaleLayer()->id(),
         inner_scroll->id(), scroll_layer->id());
     layer_tree_impl->BuildPropertyTreesForTesting();
@@ skipping 41 matching lines @@
                                                        gfx::ScrollOffset());
 
     std::unique_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(inner_viewport);
 
     std::unique_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
-    inner_scroll->SetElementId(
-        LayerIdToElementIdForTesting(inner_scroll->id()));
+    ElementId element_id;
+    element_id.id = inner_scroll->id();
+    inner_scroll->SetElementId(element_id);
     inner_scroll->SetBounds(outer_viewport);
     inner_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(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);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
-    outer_scroll->SetElementId(
-        LayerIdToElementIdForTesting(outer_scroll->id()));
+    element_id.id = outer_scroll->id();
+    outer_scroll->SetElementId(element_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);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
@@ skipping 2242 matching lines @@
                                            scrollbar_2_id, VERTICAL, 15, 0,
                                            true, true);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
   child->SetPosition(gfx::PointF(50, 50));
   child->SetBounds(child_layer_size);
   child->SetDrawsContent(true);
   child->SetScrollClipLayer(child_clip_id);
-  child->SetElementId(LayerIdToElementIdForTesting(child->id()));
-  ElementId child_element_id = child->element_id();
+  ElementId child_element_id;
+  child_element_id.id = child->id();
+  child->SetElementId(child_element_id);
+  child_element_id = child->element_id();
 
   if (main_thread_scrolling) {
     child->set_main_thread_scrolling_reasons(
         MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   }
 
   scrollbar_2->SetScrollElementId(child_element_id);
   scrollbar_2->SetDrawsContent(true);
   scrollbar_2->SetBounds(scrollbar_size_2);
   scrollbar_2->SetCurrentPos(0);
@@ skipping 172 matching lines @@
     else
       EXPECT_FALSE(tile->HasRasterTask());
   }
   Region expected_invalidation(
       raster_source->GetRectForImage(checkerable_image->uniqueID()));
   EXPECT_EQ(expected_invalidation, *(root->GetPendingInvalidation()));
 }
 
 }  // namespace
 }  // namespace cc