Change cc::ElementId to be a uint64_t

cc/animation/animation_host.cc

 // Copyright 2015 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/animation/animation_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 111 matching lines @@
 void AnimationHost::RegisterPlayerForElement(ElementId element_id,
                                              AnimationPlayer* player) {
   DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
       GetElementAnimationsForElementId(element_id);
   if (!element_animations) {
     element_animations = ElementAnimations::Create();
     element_animations->SetElementId(element_id);
-    element_to_animations_map_[element_animations->element_id()] =
+    element_to_animations_map_[element_animations->element_id().id] =
         element_animations;
   }
 
   if (element_animations->animation_host() != this) {
     element_animations->SetAnimationHost(this);
     element_animations->InitAffectedElementTypes();
   }
 
   element_animations->AddPlayer(player);
 }
 
 void AnimationHost::UnregisterPlayerForElement(ElementId element_id,
                                                AnimationPlayer* player) {
   DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
       GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   element_animations->RemovePlayer(player);
 
   if (element_animations->IsEmpty()) {
     element_animations->ClearAffectedElementTypes();
-    element_to_animations_map_.erase(element_animations->element_id());
+    element_to_animations_map_.erase(element_animations->element_id().id);
     element_animations->SetAnimationHost(nullptr);
   }
 
   RemoveFromTicking(player);
 }
 
 void AnimationHost::SetMutatorHostClient(MutatorHostClient* client) {
   if (mutator_host_client_ == client)
     return;
 
@@ skipping 66 matching lines @@
           host_impl->GetTimelineById(timeline->id());
       if (timeline_impl)
         timeline->PushPropertiesTo(timeline_impl);
     }
   }
 
   // Sync properties for created ElementAnimations.
   for (auto& kv : element_to_animations_map_) {
     const auto& element_animations = kv.second;
     if (element_animations->needs_push_properties()) {
+      ElementId element_id;
+      element_id.id = kv.first;
       auto element_animations_impl =
-          host_impl->GetElementAnimationsForElementId(kv.first);
+          host_impl->GetElementAnimationsForElementId(element_id);
       if (element_animations_impl)
         element_animations->PushPropertiesTo(
             std::move(element_animations_impl));
     }
   }
 
   // Update the impl-only scroll offset animations.
   scroll_offset_animations_->PushPropertiesTo(
       host_impl->scroll_offset_animations_impl_.get());
 }
 
 scoped_refptr<ElementAnimations>
 AnimationHost::GetElementAnimationsForElementId(ElementId element_id) const {
   if (!element_id)
     return nullptr;
-  auto iter = element_to_animations_map_.find(element_id);
+  auto iter = element_to_animations_map_.find(element_id.id);
   return iter == element_to_animations_map_.end() ? nullptr : iter->second;
 }
 
 void AnimationHost::SetSupportsScrollAnimations(
     bool supports_scroll_animations) {
   supports_scroll_animations_ = supports_scroll_animations;
 }
 
 bool AnimationHost::SupportsScrollAnimations() const {
   return supports_scroll_animations_;
@@ skipping 52 matching lines @@
       base::WrapUnique(static_cast<AnimationEvents*>(mutator_events.release()));
 
   for (size_t event_index = 0; event_index < events->events_.size();
        ++event_index) {
     ElementId element_id = events->events_[event_index].element_id;
 
     // Use the map of all ElementAnimations, not just ticking players, since
     // non-ticking Players may still receive events for impl-only animations.
     const ElementToAnimationsMap& all_element_animations =
         element_to_animations_map_;
-    auto iter = all_element_animations.find(element_id);
+    auto iter = all_element_animations.find(element_id.id);
     if (iter != all_element_animations.end()) {
       switch (events->events_[event_index].type) {
         case AnimationEvent::STARTED:
           (*iter).second->NotifyAnimationStarted(events->events_[event_index]);
           break;
 
         case AnimationEvent::FINISHED:
           (*iter).second->NotifyAnimationFinished(events->events_[event_index]);
           break;
 
@@ skipping 230 matching lines @@
     const {
   return ticking_players_;
 }
 
 const AnimationHost::ElementToAnimationsMap&
 AnimationHost::element_animations_for_testing() const {
   return element_to_animations_map_;
 }
 
 }  // namespace cc