Move Priority enum/field to KeyframeEffectReadOnly

third_party/WebKit/Source/core/animation/KeyframeEffect.h

 /*
  * 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 37 matching lines @@
 class KeyframeEffectOptions;
 class PropertyHandle;
 class SampledEffect;
 
 // Represents the effect of an Animation on an Element's properties.
 // http://w3c.github.io/web-animations/#keyframe-effect
 class CORE_EXPORT KeyframeEffect final : public KeyframeEffectReadOnly {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  enum Priority { DefaultPriority, TransitionPriority };
-
   static KeyframeEffect* create(Element*,
                                 EffectModel*,
                                 const Timing&,
-                                Priority = DefaultPriority,
+                                KeyframeEffectReadOnly::Priority =
+                                    KeyframeEffectReadOnly::DefaultPriority,
                                 EventDelegate* = nullptr);
   // Web Animations API Bindings constructors.
   static KeyframeEffect* create(
       ExecutionContext*,
       Element*,
       const DictionarySequenceOrDictionary& effectInput,
       double duration,
       ExceptionState&);
   static KeyframeEffect* create(
       ExecutionContext*,
       Element*,
       const DictionarySequenceOrDictionary& effectInput,
       const KeyframeEffectOptions& timingInput,
       ExceptionState&);
   static KeyframeEffect* create(
       ExecutionContext*,
       Element*,
       const DictionarySequenceOrDictionary& effectInput,
       ExceptionState&);
 
   ~KeyframeEffect() override;
 
   bool isKeyframeEffect() const override { return true; }
 
   bool affects(PropertyHandle) const;
   const EffectModel* model() const { return m_model.get(); }
   EffectModel* model() { return m_model.get(); }
   void setModel(EffectModel* model) { m_model = model; }
-  Priority getPriority() const { return m_priority; }
   Element* target() const { return m_target; }
 
   void notifySampledEffectRemovedFromAnimationStack();
 
   bool isCandidateForAnimationOnCompositor(double animationPlaybackRate) const;
   // Must only be called once.
   bool maybeStartAnimationOnCompositor(int group,
                                        double startTime,
                                        double timeOffset,
                                        double animationPlaybackRate);
   bool hasActiveAnimationsOnCompositor() const;
   bool hasActiveAnimationsOnCompositor(CSSPropertyID) const;
   bool cancelAnimationOnCompositor();
   void restartAnimationOnCompositor();
   void cancelIncompatibleAnimationsOnCompositor();
   void pauseAnimationForTestingOnCompositor(double pauseTime);
 
   void attachCompositedLayers();
 
   void setCompositorAnimationIdsForTesting(
       const Vector<int>& compositorAnimationIds) {
     m_compositorAnimationIds = compositorAnimationIds;
   }
 
   AnimationEffectTiming* timing() override;
 
   DECLARE_VIRTUAL_TRACE();
 
-  void downgradeToNormal() { m_priority = DefaultPriority; }
-
  protected:
   void applyEffects();
   void clearEffects();
   void updateChildrenAndEffects() const override;
   void attach(Animation*) override;
   void detach() override;
   void specifiedTimingChanged() override;
   double calculateTimeToEffectChange(bool forwards,
                                      double inheritedTime,
                                      double timeToNextIteration) const override;
   virtual bool hasIncompatibleStyle();
   bool hasMultipleTransformProperties() const;
 
  private:
   KeyframeEffect(Element*,
                  EffectModel*,
                  const Timing&,
-                 Priority,
+                 KeyframeEffectReadOnly::Priority,
                  EventDelegate*);
 
-  Priority m_priority;
   Vector<int> m_compositorAnimationIds;
 
   friend class AnimationAnimationV8Test;
 };
 
 DEFINE_TYPE_CASTS(KeyframeEffect,
                   AnimationEffectReadOnly,
                   animationNode,
                   animationNode->isKeyframeEffect(),
                   animationNode.isKeyframeEffect());
 
 }  // namespace blink
 
 #endif  // KeyframeEffect_h