Use element id's for animations

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 60 matching lines @@
       background_color_(0),
       safe_opaque_background_color_(0),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       draw_blend_mode_(SkXfermode::kSrcOver_Mode),
       transform_tree_index_(-1),
       effect_tree_index_(-1),
       clip_tree_index_(-1),
       scroll_tree_index_(-1),
       sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
-      element_id_(0),
       mutable_properties_(MutableProperty::kNone),
       debug_info_(nullptr),
       scrolls_drawn_descendant_(false),
       has_will_change_transform_hint_(false) {
   DCHECK_GT(layer_id_, 0);
 
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
   layer_tree_impl_->AddToElementMap(this);
 
@@ skipping 850 matching lines @@
 }
 
 bool LayerImpl::OpacityIsAnimating() const {
   return layer_tree_impl_->IsAnimatingOpacityProperty(this);
 }
 
 bool LayerImpl::HasPotentiallyRunningOpacityAnimation() const {
   return layer_tree_impl_->HasPotentiallyRunningOpacityAnimation(this);
 }
 
-void LayerImpl::SetElementId(uint64_t element_id) {
+void LayerImpl::SetElementId(ElementId element_id) {
   if (element_id == element_id_)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
-               "LayerImpl::SetElementId", "id", element_id);
+               "LayerImpl::SetElementId", "element",
+               element_id.AsValue().release());
 
   layer_tree_impl_->RemoveFromElementMap(this);
   element_id_ = element_id;
   layer_tree_impl_->AddToElementMap(this);
+
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetMutableProperties(uint32_t properties) {
   if (mutable_properties_ == properties)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerImpl::SetMutableProperties", "properties", properties);
 
@@ skipping 170 matching lines @@
   MathUtil::AddToTracedValue("bounds", bounds_, state);
 
   state->SetDouble("opacity", Opacity());
 
   MathUtil::AddToTracedValue("position", position_, state);
 
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage",
                     base::saturated_cast<int>(GPUMemoryUsageInBytes()));
 
-  if (mutable_properties_ != MutableProperty::kNone) {
-    state->SetInteger("element_id", base::saturated_cast<int>(element_id_));
+  if (element_id_)
+    element_id_.AddToTracedValue(state);
+
+  if (mutable_properties_ != MutableProperty::kNone)
     state->SetInteger("mutable_properties", mutable_properties_);
-  }
 
   MathUtil::AddToTracedValue("scroll_offset", CurrentScrollOffset(), state);
 
   if (!transform().IsIdentity())
     MathUtil::AddToTracedValue("transform", transform(), state);
 
   bool clipped;
   gfx::QuadF layer_quad =
       MathUtil::MapQuad(ScreenSpaceTransform(),
                         gfx::QuadF(gfx::RectF(gfx::Rect(bounds()))), &clipped);
@@ skipping 195 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc