Change cc::ElementId to be a uint64_t

cc/trees/layer_tree_impl.cc

Index: cc/trees/layer_tree_impl.cc
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 1fe5871b8a0bc4da2f26728082415c94c7f2dd51..0e7741387730c11d2132870f5e711cc1256a426f 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -519,7 +519,7 @@ LayerImplList::reverse_iterator LayerTreeImpl::rend() {
 }
 
 int LayerTreeImpl::LayerIdByElementId(ElementId element_id) const {
-  auto iter = element_layers_map_.find(element_id);
+  auto iter = element_layers_map_.find(element_id.id);

[wkorman, 2017/05/08 18:23:24]

Similar to my prev comment re: hash, there must be STL operator, interface, etc.
to reduce this verbosity here and below in this file in particular among those
in change.

   if (iter == element_layers_map_.end())
     return Layer::INVALID_ID;
 
@@ -536,8 +536,8 @@ void LayerTreeImpl::AddToElementMap(LayerImpl* layer) {
     return;
 
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
-               "LayerTreeImpl::AddToElementMap", "element",
-               element_id.AsValue().release(), "layer_id", layer->id());
+               "LayerTreeImpl::AddToElementMap", "element", element_id.id,
+               "layer_id", layer->id());
 
 #if DCHECK_IS_ON()
   LayerImpl* existing_layer = LayerByElementId(element_id);
@@ -551,7 +551,7 @@ void LayerTreeImpl::AddToElementMap(LayerImpl* layer) {
     DCHECK(!element_id_collision_detected);
 #endif
 
-  element_layers_map_[element_id] = layer->id();
+  element_layers_map_[element_id.id] = layer->id();
 
   layer_tree_host_impl_->mutator_host()->RegisterElement(
       element_id,
@@ -564,26 +564,25 @@ void LayerTreeImpl::RemoveFromElementMap(LayerImpl* layer) {
 
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeImpl::RemoveFromElementMap", "element",
-               layer->element_id().AsValue().release(), "layer_id",
-               layer->id());
+               layer->element_id().id, "layer_id", layer->id());
 
   layer_tree_host_impl_->mutator_host()->UnregisterElement(
       layer->element_id(),
       IsActiveTree() ? ElementListType::ACTIVE : ElementListType::PENDING);
 
-  element_layers_map_.erase(layer->element_id());
+  element_layers_map_.erase(layer->element_id().id);
 }
 
 void LayerTreeImpl::AddToOpacityAnimationsMap(int id, float opacity) {
   if (LayerImpl* layer = LayerById(id))
-    element_id_to_opacity_animations_[layer->element_id()] = opacity;
+    element_id_to_opacity_animations_[layer->element_id().id] = opacity;
 }
 
 void LayerTreeImpl::SetTransformMutated(ElementId element_id,
                                         const gfx::Transform& transform) {
   DCHECK_EQ(1u, property_trees()->element_id_to_transform_node_index.count(
                     element_id));
-  element_id_to_transform_animations_[element_id] = transform;
+  element_id_to_transform_animations_[element_id.id] = transform;
   if (!property_trees()->transform_tree.OnTransformAnimated(element_id,
                                                             transform))
     return;
@@ -597,7 +596,7 @@ void LayerTreeImpl::SetTransformMutated(ElementId element_id,
 void LayerTreeImpl::SetOpacityMutated(ElementId element_id, float opacity) {
   DCHECK_EQ(
       1u, property_trees()->element_id_to_effect_node_index.count(element_id));
-  element_id_to_opacity_animations_[element_id] = opacity;
+  element_id_to_opacity_animations_[element_id.id] = opacity;
   if (property_trees()->effect_tree.OnOpacityAnimated(element_id, opacity))
     set_needs_update_draw_properties();
 }
@@ -606,7 +605,7 @@ void LayerTreeImpl::SetFilterMutated(ElementId element_id,
                                      const FilterOperations& filters) {
   DCHECK_EQ(
       1u, property_trees()->element_id_to_effect_node_index.count(element_id));
-  element_id_to_filter_animations_[element_id] = filters;
+  element_id_to_filter_animations_[element_id.id] = filters;
   if (property_trees()->effect_tree.OnFilterAnimated(element_id, filters))
     set_needs_update_draw_properties();
 }
@@ -701,9 +700,10 @@ void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread(
   const bool can_delete_animations = !is_impl_side_update;
   auto element_id_to_opacity = element_id_to_opacity_animations_.begin();
   while (element_id_to_opacity != element_id_to_opacity_animations_.end()) {
-    const ElementId id = element_id_to_opacity->first;
+    ElementId element_id;
+    element_id.id = element_id_to_opacity->first;
     if (EffectNode* node =
-            property_trees_.effect_tree.FindNodeFromElementId(id)) {
+            property_trees_.effect_tree.FindNodeFromElementId(element_id)) {
       if ((!node->is_currently_animating_opacity ||
            node->opacity == element_id_to_opacity->second) &&
           can_delete_animations) {
@@ -718,9 +718,10 @@ void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread(
 
   auto element_id_to_filter = element_id_to_filter_animations_.begin();
   while (element_id_to_filter != element_id_to_filter_animations_.end()) {
-    const ElementId id = element_id_to_filter->first;
+    ElementId element_id;
+    element_id.id = element_id_to_filter->first;
     if (EffectNode* node =
-            property_trees_.effect_tree.FindNodeFromElementId(id)) {
+            property_trees_.effect_tree.FindNodeFromElementId(element_id)) {
       if ((!node->is_currently_animating_filter ||
            node->filters == element_id_to_filter->second) &&
           can_delete_animations) {
@@ -735,9 +736,10 @@ void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread(
 
   auto element_id_to_transform = element_id_to_transform_animations_.begin();
   while (element_id_to_transform != element_id_to_transform_animations_.end()) {
-    const ElementId id = element_id_to_transform->first;
+    ElementId element_id;
+    element_id.id = element_id_to_transform->first;
     if (TransformNode* node =
-            property_trees_.transform_tree.FindNodeFromElementId(id)) {
+            property_trees_.transform_tree.FindNodeFromElementId(element_id)) {
       if ((!node->is_currently_animating ||
            node->local == element_id_to_transform->second) &&
           can_delete_animations) {
@@ -985,7 +987,9 @@ void LayerTreeImpl::ClearViewportLayers() {
 
 // For unit tests, we use the layer's id as its element id.
 static void SetElementIdForTesting(LayerImpl* layer) {
-  layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
+  ElementId element_id;
+  element_id.id = layer->id();
+  layer->SetElementId(element_id);
 }
 
 void LayerTreeImpl::SetElementIdsForTesting() {
@@ -1233,9 +1237,9 @@ void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   layers_that_should_push_properties_.erase(layer);
-  element_id_to_transform_animations_.erase(layer->element_id());
-  element_id_to_opacity_animations_.erase(layer->element_id());
-  element_id_to_filter_animations_.erase(layer->element_id());
+  element_id_to_transform_animations_.erase(layer->element_id().id);
+  element_id_to_opacity_animations_.erase(layer->element_id().id);
+  element_id_to_filter_animations_.erase(layer->element_id().id);
   layer_id_map_.erase(layer->id());
 }