Add TransitionKeyframeEffectModel specialisation

third_party/WebKit/Source/core/animation/KeyframeEffectModel.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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef KeyframeEffectModel_h
 #define KeyframeEffectModel_h
 
+#include <memory>
 #include "core/CoreExport.h"
 #include "core/animation/AnimationEffectReadOnly.h"
 #include "core/animation/EffectModel.h"
 #include "core/animation/InterpolationEffect.h"
 #include "core/animation/PropertyHandle.h"
 #include "core/animation/StringKeyframe.h"
+#include "core/animation/TransitionKeyframe.h"
 #include "core/animation/animatable/AnimatableValueKeyframe.h"
 #include "platform/animation/TimingFunction.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/Vector.h"
-#include <memory>
 
 namespace blink {
 
 class Element;
 class KeyframeEffectModelTest;
 
 class CORE_EXPORT KeyframeEffectModelBase : public EffectModel {
  public:
   // FIXME: Implement accumulation.
 
@@ skipping 40 matching lines @@
   // EffectModel implementation.
   bool sample(int iteration,
               double fraction,
               double iterationDuration,
               Vector<RefPtr<Interpolation>>&) const override;
 
   bool isKeyframeEffectModel() const override { return true; }
 
   virtual bool isAnimatableValueKeyframeEffectModel() const { return false; }
   virtual bool isStringKeyframeEffectModel() const { return false; }
+  virtual bool isTransitionKeyframeEffectModel() const { return false; }
 
   bool hasSyntheticKeyframes() const {
     ensureKeyframeGroups();
     return m_hasSyntheticKeyframes;
   }
 
   bool needsCompositorKeyframesSnapshot() const {
     return m_needsCompositorKeyframesSnapshot;
   }
   bool snapshotNeutralCompositorKeyframes(
@@ skipping 62 matching lines @@
 
  private:
   KeyframeEffectModel(const KeyframeVector& keyframes,
                       PassRefPtr<TimingFunction> defaultKeyframeEasing)
       : KeyframeEffectModelBase(std::move(defaultKeyframeEasing)) {
     m_keyframes.appendVector(keyframes);
   }
 
   virtual bool isAnimatableValueKeyframeEffectModel() const { return false; }
   virtual bool isStringKeyframeEffectModel() const { return false; }
+  virtual bool isTransitionKeyframeEffectModel() const { return false; }
 };
 
 using KeyframeVector = KeyframeEffectModelBase::KeyframeVector;
 using PropertySpecificKeyframeVector =
     KeyframeEffectModelBase::PropertySpecificKeyframeVector;
 
 using AnimatableValueKeyframeEffectModel =
     KeyframeEffectModel<AnimatableValueKeyframe>;
 using AnimatableValueKeyframeVector =
     AnimatableValueKeyframeEffectModel::KeyframeVector;
 using AnimatableValuePropertySpecificKeyframeVector =
     AnimatableValueKeyframeEffectModel::PropertySpecificKeyframeVector;
 
 using StringKeyframeEffectModel = KeyframeEffectModel<StringKeyframe>;
 using StringKeyframeVector = StringKeyframeEffectModel::KeyframeVector;
 using StringPropertySpecificKeyframeVector =
     StringKeyframeEffectModel::PropertySpecificKeyframeVector;
 
+using TransitionKeyframeEffectModel = KeyframeEffectModel<TransitionKeyframe>;
+using TransitionKeyframeVector = TransitionKeyframeEffectModel::KeyframeVector;
+using TransitionPropertySpecificKeyframeVector =
+    TransitionKeyframeEffectModel::PropertySpecificKeyframeVector;
+
 DEFINE_TYPE_CASTS(KeyframeEffectModelBase,
                   EffectModel,
                   value,
                   value->isKeyframeEffectModel(),
                   value.isKeyframeEffectModel());
 DEFINE_TYPE_CASTS(AnimatableValueKeyframeEffectModel,
                   KeyframeEffectModelBase,
                   value,
                   value->isAnimatableValueKeyframeEffectModel(),
                   value.isAnimatableValueKeyframeEffectModel());
 DEFINE_TYPE_CASTS(StringKeyframeEffectModel,
                   KeyframeEffectModelBase,
                   value,
                   value->isStringKeyframeEffectModel(),
                   value.isStringKeyframeEffectModel());
+DEFINE_TYPE_CASTS(TransitionKeyframeEffectModel,
+                  KeyframeEffectModelBase,
+                  value,
+                  value->isTransitionKeyframeEffectModel(),
+                  value.isTransitionKeyframeEffectModel());
 
 inline const AnimatableValueKeyframeEffectModel*
 toAnimatableValueKeyframeEffectModel(const EffectModel* base) {
   return toAnimatableValueKeyframeEffectModel(toKeyframeEffectModelBase(base));
 }
 
 inline AnimatableValueKeyframeEffectModel* toAnimatableValueKeyframeEffectModel(
     EffectModel* base) {
   return toAnimatableValueKeyframeEffectModel(toKeyframeEffectModelBase(base));
 }
 
 inline const StringKeyframeEffectModel* toStringKeyframeEffectModel(
     const EffectModel* base) {
   return toStringKeyframeEffectModel(toKeyframeEffectModelBase(base));
 }
 
 inline StringKeyframeEffectModel* toStringKeyframeEffectModel(
     EffectModel* base) {
   return toStringKeyframeEffectModel(toKeyframeEffectModelBase(base));
 }
 
+inline TransitionKeyframeEffectModel* toTransitionKeyframeEffectModel(
+    EffectModel* base) {
+  return toTransitionKeyframeEffectModel(toKeyframeEffectModelBase(base));
+}
+
 template <>
 inline bool KeyframeEffectModel<
     AnimatableValueKeyframe>::isAnimatableValueKeyframeEffectModel() const {
   return true;
 }
 
 template <>
 inline bool KeyframeEffectModel<StringKeyframe>::isStringKeyframeEffectModel()
     const {
   return true;
 }
 
+template <>
+inline bool KeyframeEffectModel<
+    TransitionKeyframe>::isTransitionKeyframeEffectModel() const {
+  return true;
+}
+
 }  // namespace blink
 
 #endif  // KeyframeEffectModel_h