Change cc::ElementId to be a uint64_t

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 501 matching lines @@
 
 LayerImplList::reverse_iterator LayerTreeImpl::rbegin() {
   return layer_list_.rbegin();
 }
 
 LayerImplList::reverse_iterator LayerTreeImpl::rend() {
   return layer_list_.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;
 
   return iter->second;
 }
 
 LayerImpl* LayerTreeImpl::LayerByElementId(ElementId element_id) const {
   return LayerById(LayerIdByElementId(element_id));
 }
 
 void LayerTreeImpl::AddToElementMap(LayerImpl* layer) {
   ElementId element_id = layer->element_id();
   if (!element_id)
     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);
   bool element_id_collision_detected =
       existing_layer && existing_layer != layer;
 
   // TODO(pdr): Remove this suppression and always check for id collisions.
   // This is a temporary suppression for SPV2 which generates unnecessary
   // layers that collide. Remove once crbug.com/693693 is fixed.
   if (!settings().use_layer_lists)
     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,
       IsActiveTree() ? ElementListType::ACTIVE : ElementListType::PENDING);
 }
 
 void LayerTreeImpl::RemoveFromElementMap(LayerImpl* layer) {
   if (!layer->element_id())
     return;
 
   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;
 
   if (LayerImpl* layer = LayerByElementId(element_id))
     layer->set_was_ever_ready_since_last_transform_animation(false);
 
   set_needs_update_draw_properties();
 }
 
 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();
 }
 
 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();
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
   return InnerViewportScrollLayer()
              ? InnerViewportScrollLayer()->scroll_clip_layer()
              : NULL;
 }
 
@@ skipping 74 matching lines @@
   // frame to a newly-committed property tree.
   if (layer_list_.empty())
     return;
 
   // Entries from |element_id_to_*_animations_| should be deleted only after
   // they have been synchronized with the main thread, which will not be the
   // case if this is an impl-side invalidation.
   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) {
         element_id_to_opacity_animations_.erase(element_id_to_opacity++);
         continue;
       }
       node->opacity = element_id_to_opacity->second;
       property_trees_.effect_tree.set_needs_update(true);
     }
     ++element_id_to_opacity;
   }
 
   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) {
         element_id_to_filter_animations_.erase(element_id_to_filter++);
         continue;
       }
       node->filters = element_id_to_filter->second;
       property_trees_.effect_tree.set_needs_update(true);
     }
     ++element_id_to_filter;
   }
 
   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) {
         element_id_to_transform_animations_.erase(element_id_to_transform++);
         continue;
       }
       node->local = element_id_to_transform->second;
       node->needs_local_transform_update = true;
       property_trees_.transform_tree.set_needs_update(true);
     }
@@ skipping 227 matching lines @@
 
 void LayerTreeImpl::ClearViewportLayers() {
   overscroll_elasticity_layer_id_ = Layer::INVALID_ID;
   page_scale_layer_id_ = Layer::INVALID_ID;
   inner_viewport_scroll_layer_id_ = Layer::INVALID_ID;
   outer_viewport_scroll_layer_id_ = Layer::INVALID_ID;
 }
 
 // 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() {
   LayerListIterator<LayerImpl> it(root_layer_for_testing_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
     if (!it->element_id())
       SetElementIdForTesting(*it);
   }
 }
 
@@ skipping 227 matching lines @@
 }
 
 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
   DCHECK(!LayerById(layer->id()));
   layer_id_map_[layer->id()] = 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());
 }
 
 // These manage ownership of the LayerImpl.
 void LayerTreeImpl::AddLayer(std::unique_ptr<LayerImpl> layer) {
   DCHECK(std::find(layers_->begin(), layers_->end(), layer) == layers_->end());
   DCHECK(layer);
   layers_->push_back(std::move(layer));
   set_needs_update_draw_properties();
 }
@@ skipping 839 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc