Rename AnimationPlayerEvent as AnimationPlaybackEvent

third_party/WebKit/Source/core/animation/Animation.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #include "core/animation/Animation.h"
 
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorPendingAnimations.h"
 #include "core/animation/KeyframeEffect.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/StyleChangeReason.h"
-#include "core/events/AnimationPlayerEvent.h"
+#include "core/events/AnimationPlaybackEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
@@ skipping 778 matching lines @@
             inheritedTime = -1;
         m_content->updateInheritedTime(inheritedTime, reason);
     }
 
     if ((idle || limited()) && !m_finished) {
         if (reason == TimingUpdateForAnimationFrame && (idle || hasStartTime())) {
             if (idle) {
                 const AtomicString& eventType = EventTypeNames::cancel;
                 if (getExecutionContext() && hasEventListeners(eventType)) {
                     double eventCurrentTime = nullValue();
-                    m_pendingCancelledEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
+                    m_pendingCancelledEvent = AnimationPlaybackEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                     m_pendingCancelledEvent->setTarget(this);
                     m_pendingCancelledEvent->setCurrentTarget(this);
                     m_timeline->document()->enqueueAnimationFrameEvent(m_pendingCancelledEvent);
                 }
             } else {
                 const AtomicString& eventType = EventTypeNames::finish;
                 if (getExecutionContext() && hasEventListeners(eventType)) {
                     double eventCurrentTime = currentTimeInternal() * 1000;
-                    m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
+                    m_pendingFinishedEvent = AnimationPlaybackEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                     m_pendingFinishedEvent->setTarget(this);
                     m_pendingFinishedEvent->setCurrentTarget(this);
                     m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent);
                 }
             }
             m_finished = true;
         }
     }
     DCHECK(!m_outdated);
     return !m_finished || std::isfinite(timeToEffectChange());
@@ skipping 242 matching lines @@
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_pendingCancelledEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink