Devtools Animations: Basic animation inspection & control in Styles pane

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/InspectorDOMAgent.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/InputTypeNames.h"
+#include "core/animation/AnimationNode.h"
+#include "core/animation/AnimationPlayer.h"
+#include "core/animation/ElementAnimation.h"
 #include "core/dom/Attr.h"
 #include "core/dom/CharacterData.h"
 #include "core/dom/ContainerNode.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
 #include "core/dom/PseudoElement.h"
@@ skipping 386 matching lines @@
     if (!node)
         return 0;
 
     if (!node->isElementNode()) {
         *errorString = "Node is not an Element";
         return 0;
     }
     return toElement(node);
 }
 
+AnimationPlayer* InspectorDOMAgent::assertAnimationPlayer(ErrorString* errorString, String id)
+{
+    AnimationPlayer* player = m_idToAnimationPlayer.get(id);
+    if (!player) {
+        *errorString = "Could not find animation player with given id";
+        return 0;
+    }
+    return player;
+}
+
 static ShadowRoot* userAgentShadowRoot(Node* node)
 {
     if (!node || !node->isInShadowTree())
         return 0;
 
     Node* candidate = node;
     while (candidate && !candidate->isShadowRoot())
         candidate = candidate->parentOrShadowHostNode();
     ASSERT(candidate);
     ShadowRoot* shadowRoot = toShadowRoot(candidate);
@@ skipping 891 matching lines @@
     // FIXME: Inspector doesn't currently work cross process.
     if (frame && frame->deprecatedLocalOwner()) {
         OwnPtr<HighlightConfig> highlightConfig = adoptPtr(new HighlightConfig());
         highlightConfig->showInfo = true; // Always show tooltips for frames.
         highlightConfig->content = parseColor(color);
         highlightConfig->contentOutline = parseColor(outlineColor);
         m_overlay->highlightNode(frame->deprecatedLocalOwner(), 0 /* eventTarget */, *highlightConfig, false);
     }
 }
 
+void InspectorDOMAgent::getAnimationPlayersForNode(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::AnimationPlayer> >& animationPlayersArray)
+{
+    animationPlayersArray = TypeBuilder::Array<TypeBuilder::DOM::AnimationPlayer>::create();
+    Element* element = assertElement(errorString, nodeId);
+    if (!element)
+        return;
+    WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players = ElementAnimation::getAnimationPlayers(*element);
+    for (WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> >::iterator it = players.begin(); it != players.end(); ++it) {
+        AnimationPlayer& player = *(it->get());
+        m_idToAnimationPlayer.set(player.id(), &player);
+        RefPtr<TypeBuilder::DOM::AnimationPlayer> animationPlayerObject = buildObjectForAnimationPlayer(player);
+        animationPlayersArray->addItem(animationPlayerObject);
+    }
+}
+
+void InspectorDOMAgent::pauseAnimationPlayer(ErrorString* errorString, const String& id, RefPtr<TypeBuilder::DOM::AnimationPlayer>& animationPlayer)
+{
+    AnimationPlayer* player = assertAnimationPlayer(errorString, id);
+    if (!player)
+        return;
+    player->pause();
+    animationPlayer = buildObjectForAnimationPlayer(*player);
+}
+
+void InspectorDOMAgent::playAnimationPlayer(ErrorString* errorString, const String& id, RefPtr<TypeBuilder::DOM::AnimationPlayer>& animationPlayer)
+{
+    AnimationPlayer* player = assertAnimationPlayer(errorString, id);
+    if (!player)
+        return;
+    player->play();
+    animationPlayer = buildObjectForAnimationPlayer(*player);
+}
+
+void InspectorDOMAgent::setAnimationPlayerCurrentTime(ErrorString* errorString, const String& id, double currentTime, RefPtr<TypeBuilder::DOM::AnimationPlayer>& animationPlayer)
+{
+    AnimationPlayer* player = assertAnimationPlayer(errorString, id);
+    if (!player)
+        return;
+    player->setCurrentTime(currentTime);
+    animationPlayer = buildObjectForAnimationPlayer(*player);
+}
+
+void InspectorDOMAgent::getAnimationPlayerState(ErrorString* errorString, const String& id, double* currentTime, bool* isRunning)
+{
+    AnimationPlayer* player = assertAnimationPlayer(errorString, id);
+    if (!player)
+        return;
+    *currentTime = player->currentTime();
+    *isRunning = player->playing();
+}
+
 void InspectorDOMAgent::hideHighlight(ErrorString*)
 {
     m_overlay->hideHighlight();
 }
 
 void InspectorDOMAgent::copyTo(ErrorString* errorString, int nodeId, int targetElementId, const int* const anchorNodeId, int* newNodeId)
 {
     Node* node = assertEditableNode(errorString, nodeId);
     if (!node)
         return;
@@ skipping 401 matching lines @@
         return nullptr;
 
     RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > pseudoElements = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
     if (element->pseudoElement(BEFORE))
         pseudoElements->addItem(buildObjectForNode(element->pseudoElement(BEFORE), 0, nodesMap));
     if (element->pseudoElement(AFTER))
         pseudoElements->addItem(buildObjectForNode(element->pseudoElement(AFTER), 0, nodesMap));
     return pseudoElements.release();
 }
 
+PassRefPtr<TypeBuilder::DOM::AnimationPlayer> InspectorDOMAgent::buildObjectForAnimationPlayer(AnimationPlayer& animationPlayer)
+{
+    RefPtr<TypeBuilder::DOM::AnimationPlayer> playerObject = TypeBuilder::DOM::AnimationPlayer::create()
+        .setId(animationPlayer.id())
+        .setPaused(animationPlayer.paused())
+        .setFinished(animationPlayer.finished())
+        .setPlaybackRate(animationPlayer.playbackRate())
+        .setStartTime(animationPlayer.startTime())
+        .setCurrentTime(animationPlayer.currentTime())
+        .setAnimation(buildObjectForAnimationNode(*(animationPlayer.source())));
+    return playerObject.release();
+}
+
+PassRefPtr<TypeBuilder::DOM::AnimationNode> InspectorDOMAgent::buildObjectForAnimationNode(AnimationNode& animationNode)
+{
+    RefPtr<TypeBuilder::DOM::AnimationNode> animationObject = TypeBuilder::DOM::AnimationNode::create()
+        .setStartDelay(animationNode.specifiedTiming().startDelay)
+        .setPlaybackRate(animationNode.specifiedTiming().playbackRate)
+        .setIterationStart(animationNode.specifiedTiming().iterationStart)
+        .setIterationCount(animationNode.specifiedTiming().iterationCount)
+        .setDuration(animationNode.duration())
+        .setDirection(animationNode.specifiedTiming().direction)
+        .setFillMode(animationNode.specifiedTiming().fillMode)
+        .setTimeFraction(animationNode.timeFraction());
+    return animationObject.release();
+}
+
 Node* InspectorDOMAgent::innerFirstChild(Node* node)
 {
     node = node->firstChild();
     while (isWhitespace(node))
         node = node->nextSibling();
     return node;
 }
 
 Node* InspectorDOMAgent::innerNextSibling(Node* node)
 {
@@ skipping 407 matching lines @@
     visitor->trace(m_pageAgent);
     visitor->trace(m_injectedScriptManager);
 #if ENABLE(OILPAN)
     visitor->trace(m_documentNodeToIdMap);
     visitor->trace(m_danglingNodeToIdMaps);
     visitor->trace(m_idToNode);
     visitor->trace(m_idToNodesMap);
     visitor->trace(m_document);
     visitor->trace(m_revalidateStyleAttrTask);
     visitor->trace(m_searchResults);
+    visitor->trace(m_idToAnimationPlayer);
 #endif
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink