Revert of Use element id's for animations

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 199 matching lines @@
       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;
+  DCHECK(element_id);
   auto iter = element_to_animations_map_.find(element_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 {
@@ skipping 45 matching lines @@
 }
 
 std::unique_ptr<AnimationEvents> AnimationHost::CreateEvents() {
   return base::WrapUnique(new AnimationEvents());
 }
 
 void AnimationHost::SetAnimationEvents(
     std::unique_ptr<AnimationEvents> events) {
   for (size_t event_index = 0; event_index < events->events_.size();
        ++event_index) {
-    ElementId element_id = events->events_[event_index].element_id;
+    int event_layer_id = events->events_[event_index].element_id;
 
     // Use the map of all ElementAnimations, not just active ones, since
     // non-active ElementAnimations 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(event_layer_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 244 matching lines @@
 const AnimationHost::ElementToAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
   return element_to_animations_map_;
 }
 
 void AnimationHost::OnAnimationWaitingForDeletion() {
   animation_waiting_for_deletion_ = true;
 }
 
 }  // namespace cc