Construct KeyframeEffectReadOnly objects

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

 // Copyright 2016 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 "core/animation/KeyframeEffectReadOnly.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/animation/Animation.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/EffectInput.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffect.h"
 #include "core/animation/KeyframeEffectOptions.h"
 #include "core/animation/PropertyHandle.h"
 #include "core/animation/SampledEffect.h"
 #include "core/animation/TimingInput.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/frame/UseCounter.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGElement.h"
 
 namespace blink {
 
-// Web Animations API Bindings constructors. We never actually want to create a
-// KeyframeEffectReadOnly object, we just want to provide a read-only interface
-// to the KeyframeEffect object, so pass straight through to the subclass
-// factory methods.
+KeyframeEffectReadOnly* KeyframeEffectReadOnly::create(
+    Element* target,
+    EffectModel* model,
+    const Timing& timing,
+    Priority priority,
+    EventDelegate* eventDelegate) {
+  return new KeyframeEffectReadOnly(target, model, timing, priority,
+                                    eventDelegate);
+}
+
 KeyframeEffectReadOnly* KeyframeEffectReadOnly::create(
     ExecutionContext* executionContext,
     Element* element,
     const DictionarySequenceOrDictionary& effectInput,
     double duration,
     ExceptionState& exceptionState) {
-  return KeyframeEffect::create(executionContext, element, effectInput,
-                                duration, exceptionState);
+  DCHECK(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
+  if (element) {
+    UseCounter::count(
+        element->document(),
+        UseCounter::AnimationConstructorKeyframeListEffectObjectTiming);
+  }
+  Timing timing;
+  if (!TimingInput::convert(duration, timing, exceptionState))
+    return nullptr;
+  return create(element, EffectInput::convert(element, effectInput,
+                                              executionContext, exceptionState),
+                timing);
 }
 
 KeyframeEffectReadOnly* KeyframeEffectReadOnly::create(
     ExecutionContext* executionContext,
     Element* element,
     const DictionarySequenceOrDictionary& effectInput,
     const KeyframeEffectOptions& timingInput,
     ExceptionState& exceptionState) {
-  return KeyframeEffect::create(executionContext, element, effectInput,
-                                timingInput, exceptionState);
+  DCHECK(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
+  if (element) {
+    UseCounter::count(
+        element->document(),
+        UseCounter::AnimationConstructorKeyframeListEffectObjectTiming);
+  }
+  Timing timing;
+  Document* document = element ? &element->document() : nullptr;
+  if (!TimingInput::convert(timingInput, timing, document, exceptionState))
+    return nullptr;
+  return create(element, EffectInput::convert(element, effectInput,
+                                              executionContext, exceptionState),
+                timing);
 }
 
 KeyframeEffectReadOnly* KeyframeEffectReadOnly::create(
     ExecutionContext* executionContext,
     Element* element,
     const DictionarySequenceOrDictionary& effectInput,
     ExceptionState& exceptionState) {
-  return KeyframeEffect::create(executionContext, element, effectInput,
-                                exceptionState);
+  DCHECK(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
+  if (element) {
+    UseCounter::count(
+        element->document(),
+        UseCounter::AnimationConstructorKeyframeListEffectNoTiming);
+  }
+  return create(element, EffectInput::convert(element, effectInput,
+                                              executionContext, exceptionState),
+                Timing());
 }
 
 KeyframeEffectReadOnly::KeyframeEffectReadOnly(Element* target,
                                                EffectModel* model,
                                                const Timing& timing,
                                                Priority priority,
                                                EventDelegate* eventDelegate)
     : AnimationEffectReadOnly(timing, eventDelegate),
       m_target(target),
       m_model(model),
@@ skipping 268 matching lines @@
 }
 
 DEFINE_TRACE(KeyframeEffectReadOnly) {
   visitor->trace(m_target);
   visitor->trace(m_model);
   visitor->trace(m_sampledEffect);
   AnimationEffectReadOnly::trace(visitor);
 }
 
 }  // namespace blink