SVG Web Animations: Add compositing pipeline for SVGInterpolationTypes

third_party/WebKit/Source/core/svg/SVGDocumentExtensions.cpp

 /*
  * Copyright (C) 2006 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Rob Buis <buis@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/svg/SVGDocumentExtensions.h"
 
+#include "core/animation/AnimationStack.h"
+#include "core/animation/ElementAnimations.h"
+#include "core/animation/InterpolationEnvironment.h"
+#include "core/animation/InvalidatableInterpolation.h"
+#include "core/animation/SVGInterpolation.h"
 #include "core/dom/Document.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
@@ skipping 12 matching lines @@
 void SVGDocumentExtensions::addTimeContainer(SVGSVGElement* element)
 {
     m_timeContainers.add(element);
 }
 
 void SVGDocumentExtensions::removeTimeContainer(SVGSVGElement* element)
 {
     m_timeContainers.remove(element);
 }
 
+void SVGDocumentExtensions::addWebAnimationsPendingSVGElement(SVGElement& element)
+{
+    ASSERT(RuntimeEnabledFeatures::webAnimationsSVGEnabled());
+    m_webAnimationsPendingSVGElements.add(&element);
+}
+
 void SVGDocumentExtensions::addResource(const AtomicString& id, LayoutSVGResourceContainer* resource)
 {
     ASSERT(resource);
 
     if (id.isEmpty())
         return;
 
     // Replaces resource if already present, to handle potential id changes
     m_resources.set(id, resource);
 }
 
 void SVGDocumentExtensions::removeResource(const AtomicString& id)
 {
     if (id.isEmpty())
         return;
 
     m_resources.remove(id);
 }
 
 LayoutSVGResourceContainer* SVGDocumentExtensions::resourceById(const AtomicString& id) const
 {
     if (id.isEmpty())
         return nullptr;
 
     return m_resources.get(id);
 }
 
 void SVGDocumentExtensions::serviceOnAnimationFrame(Document& document, double monotonicAnimationStartTime)
 {
-    if (!document.svgExtensions() || !RuntimeEnabledFeatures::smilEnabled())
+    if (!document.svgExtensions())
         return;
     document.accessSVGExtensions().serviceAnimations(monotonicAnimationStartTime);
 }
 
 void SVGDocumentExtensions::serviceAnimations(double monotonicAnimationStartTime)
 {
-    WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
-    copyToVector(m_timeContainers, timeContainers);
-    for (const auto& container : timeContainers)
-        container->timeContainer()->serviceAnimations(monotonicAnimationStartTime);
+    if (RuntimeEnabledFeatures::smilEnabled()) {
+        WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
+        copyToVector(m_timeContainers, timeContainers);
+        for (const auto& container : timeContainers)
+            container->timeContainer()->serviceAnimations(monotonicAnimationStartTime);
+    }
+
+    SVGElementSet webAnimationsPendingSVGElements;
+    webAnimationsPendingSVGElements.swap(m_webAnimationsPendingSVGElements);
+
+    // TODO(alancutter): Make SVG animation effect application a separate document lifecycle phase from servicing animations to be responsive to Javascript manipulation of exposed animation objects.
+    for (auto& svgElement : webAnimationsPendingSVGElements) {
+        ActiveInterpolationsMap activeInterpolationsMap = AnimationStack::activeInterpolations(
+            &svgElement->elementAnimations()->animationStack(), nullptr, nullptr, KeyframeEffect::DefaultPriority);
+        for (auto& entry : activeInterpolationsMap) {
+            if (!entry.key.isSVGAttribute())
+                continue;
+            const QualifiedName& attribute = entry.key.svgAttribute();
+            const Interpolation& interpolation = *entry.value.first();
+            if (interpolation.isInvalidatableInterpolation()) {
+                InterpolationEnvironment environment(*svgElement, svgElement->propertyFromAttribute(attribute)->baseValueBase());
+                InvalidatableInterpolation::applyStack(entry.value, environment);
+            } else {
+                // TODO(alancutter): Remove this old code path once animations have completely migrated to InterpolationTypes.
+                toSVGInterpolation(interpolation).apply(*svgElement);
+            }
+        }
+    }
+
+    ASSERT(m_webAnimationsPendingSVGElements.isEmpty());
 }
 
 void SVGDocumentExtensions::startAnimations()
 {
     // FIXME: Eventually every "Time Container" will need a way to latch on to some global timer
     // starting animations for a document will do this "latching"
     // FIXME: We hold a ref pointers to prevent a shadow tree from getting removed out from underneath us.
     // In the future we should refactor the use-element to avoid this. See https://webkit.org/b/53704
     WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
     copyToVector(m_timeContainers, timeContainers);
@@ skipping 242 matching lines @@
 {
     ASSERT(m_document);
     return rootElement(*m_document);
 }
 
 DEFINE_TRACE(SVGDocumentExtensions)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_timeContainers);
+    visitor->trace(m_webAnimationsPendingSVGElements);
     visitor->trace(m_relativeLengthSVGRoots);
     visitor->trace(m_pendingResources);
     visitor->trace(m_pendingResourcesForRemoval);
 #endif
 }
 
 }