Use kCamelCase in Document::ListenerType enum

third_party/WebKit/Source/core/animation/css/CSSAnimations.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 1056 matching lines @@
   if (animation_target_->GetDocument().HasListenerType(listener_type)) {
     AnimationEvent* event =
         AnimationEvent::Create(event_name, name_, elapsed_time);
     event->SetTarget(GetEventTarget());
     GetDocument().EnqueueAnimationFrameEvent(event);
   }
 }
 
 bool CSSAnimations::AnimationEventDelegate::RequiresIterationEvents(
     const AnimationEffectReadOnly& animation_node) {
-  return GetDocument().HasListenerType(Document::ANIMATIONITERATION_LISTENER);
+  return GetDocument().HasListenerType(Document::kAnimationIterationListener);
 }
 
 void CSSAnimations::AnimationEventDelegate::OnEventCondition(
     const AnimationEffectReadOnly& animation_node) {
   const AnimationEffectReadOnly::Phase current_phase =
       animation_node.GetPhase();
   const double current_iteration = animation_node.CurrentIteration();
 
   if (previous_phase_ != current_phase &&
       (current_phase == AnimationEffectReadOnly::kPhaseActive ||
        current_phase == AnimationEffectReadOnly::kPhaseAfter) &&
       (previous_phase_ == AnimationEffectReadOnly::kPhaseNone ||
        previous_phase_ == AnimationEffectReadOnly::kPhaseBefore)) {
     const double start_delay = animation_node.SpecifiedTiming().start_delay;
     const double elapsed_time = start_delay < 0 ? -start_delay : 0;
-    MaybeDispatch(Document::ANIMATIONSTART_LISTENER,
+    MaybeDispatch(Document::kAnimationStartListener,
                   EventTypeNames::animationstart, elapsed_time);
   }
 
   if (current_phase == AnimationEffectReadOnly::kPhaseActive &&
       previous_phase_ == current_phase &&
       previous_iteration_ != current_iteration) {
     // We fire only a single event for all iterations thast terminate
     // between a single pair of samples. See http://crbug.com/275263. For
     // compatibility with the existing implementation, this event uses
     // the elapsedTime for the first iteration in question.
     DCHECK(!std::isnan(animation_node.SpecifiedTiming().iteration_duration));
     const double elapsed_time =
         animation_node.SpecifiedTiming().iteration_duration *
         (previous_iteration_ + 1);
-    MaybeDispatch(Document::ANIMATIONITERATION_LISTENER,
+    MaybeDispatch(Document::kAnimationIterationListener,
                   EventTypeNames::animationiteration, elapsed_time);
   }
 
   if (current_phase == AnimationEffectReadOnly::kPhaseAfter &&
       previous_phase_ != AnimationEffectReadOnly::kPhaseAfter)
-    MaybeDispatch(Document::ANIMATIONEND_LISTENER, EventTypeNames::animationend,
+    MaybeDispatch(Document::kAnimationEndListener, EventTypeNames::animationend,
                   animation_node.ActiveDurationInternal());
 
   previous_phase_ = current_phase;
   previous_iteration_ = current_iteration;
 }
 
 DEFINE_TRACE(CSSAnimations::AnimationEventDelegate) {
   visitor->Trace(animation_target_);
   AnimationEffectReadOnly::EventDelegate::Trace(visitor);
 }
 
 EventTarget* CSSAnimations::TransitionEventDelegate::GetEventTarget() const {
   return EventPath::EventTargetRespectingTargetRules(*transition_target_);
 }
 
 void CSSAnimations::TransitionEventDelegate::OnEventCondition(
     const AnimationEffectReadOnly& animation_node) {
   const AnimationEffectReadOnly::Phase current_phase =
       animation_node.GetPhase();
   if (current_phase == AnimationEffectReadOnly::kPhaseAfter &&
       current_phase != previous_phase_ &&
-      GetDocument().HasListenerType(Document::TRANSITIONEND_LISTENER)) {
+      GetDocument().HasListenerType(Document::kTransitionEndListener)) {
     String property_name = property_.IsCSSCustomProperty()
                                ? property_.CustomPropertyName()
                                : getPropertyNameString(property_.CssProperty());
     const Timing& timing = animation_node.SpecifiedTiming();
     double elapsed_time = timing.iteration_duration;
     const AtomicString& event_type = EventTypeNames::transitionend;
     String pseudo_element =
         PseudoElement::PseudoElementNameForEvents(GetPseudoId());
     TransitionEvent* event = TransitionEvent::Create(
         event_type, property_name, elapsed_time, pseudo_element);
@@ skipping 83 matching lines @@
              IsCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->Trace(transitions_);
   visitor->Trace(pending_update_);
   visitor->Trace(running_animations_);
 }
 
 }  // namespace blink