Devtools Animations: Basic animation inspection & control in Styles pane

Source/core/inspector/InspectorDOMAgent.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 124 matching lines @@
     virtual void getAttributes(ErrorString*, int nodeId, RefPtr<TypeBuilder::Array<String> >& result) override;
     virtual void setInspectModeEnabled(ErrorString*, bool enabled, const bool* inspectUAShadowDOM, const RefPtr<JSONObject>* highlightConfig) override;
     virtual void requestNode(ErrorString*, const String& objectId, int* nodeId) override;
     virtual void pushNodeByPathToFrontend(ErrorString*, const String& path, int* nodeId) override;
     virtual void pushNodesByBackendIdsToFrontend(ErrorString*, const RefPtr<JSONArray>& nodeIds, RefPtr<TypeBuilder::Array<int> >&) override;
     virtual void hideHighlight(ErrorString*) override;
     virtual void highlightRect(ErrorString*, int x, int y, int width, int height, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor) override;
     virtual void highlightQuad(ErrorString*, const RefPtr<JSONArray>& quad, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor) override;
     virtual void highlightNode(ErrorString*, const RefPtr<JSONObject>& highlightConfig, const int* nodeId, const String* objectId) override;
     virtual void highlightFrame(ErrorString*, const String& frameId, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor) override;
+    virtual void getAnimationPlayersForNode(ErrorString*, int nodeId, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::AnimationPlayer> >& animationPlayersArray) override;
+    virtual void pauseAnimationPlayer(ErrorString*, const String& id, RefPtr<TypeBuilder::DOM::AnimationPlayer>&) override;
+    virtual void playAnimationPlayer(ErrorString*, const String& id, RefPtr<TypeBuilder::DOM::AnimationPlayer>&) override;
+    virtual void setAnimationPlayerCurrentTime(ErrorString*, const String& id, double currentTime, RefPtr<TypeBuilder::DOM::AnimationPlayer>&) override;
+    virtual void getAnimationPlayerState(ErrorString*, const String& id, double* currentTime, bool* isRunning) override;
 
     virtual void copyTo(ErrorString*, int nodeId, int targetElementId, const int* anchorNodeId, int* newNodeId) override;
     virtual void moveTo(ErrorString*, int nodeId, int targetNodeId, const int* anchorNodeId, int* newNodeId) override;
     virtual void undo(ErrorString*) override;
     virtual void redo(ErrorString*) override;
     virtual void markUndoableState(ErrorString*) override;
     virtual void focus(ErrorString*, int nodeId) override;
     virtual void setFileInputFiles(ErrorString*, int nodeId, const RefPtr<JSONArray>& files) override;
     virtual void getBoxModel(ErrorString*, int nodeId, RefPtr<TypeBuilder::DOM::BoxModel>&) override;
     virtual void getNodeForLocation(ErrorString*, int x, int y, int* nodeId) override;
     virtual void getRelayoutBoundary(ErrorString*, int nodeId, int* relayoutBoundaryNodeId) override;
+
     static void getEventListeners(EventTarget*, Vector<EventListenerInfo>& listenersArray, bool includeAncestors);
 
     class Listener : public WillBeGarbageCollectedMixin {
     public:
         virtual ~Listener() { }
         virtual void domAgentWasEnabled() = 0;
         virtual void domAgentWasDisabled() = 0;
     };
     void setListener(Listener* listener) { m_listener = listener; }
 
@@ skipping 39 matching lines @@
     static Node* innerFirstChild(Node*);
     static Node* innerNextSibling(Node*);
     static Node* innerPreviousSibling(Node*);
     static unsigned innerChildNodeCount(Node*);
     static Node* innerParentNode(Node*);
     static bool isWhitespace(Node*);
 
     Node* assertNode(ErrorString*, int nodeId);
     Element* assertElement(ErrorString*, int nodeId);
     Document* assertDocument(ErrorString*, int nodeId);
+    AnimationPlayer* assertAnimationPlayer(ErrorString*, const String& id);
 
 private:
     enum SearchMode { NotSearching, SearchingForNormal, SearchingForUAShadow };
 
     InspectorDOMAgent(InspectorPageAgent*, InjectedScriptManager*, InspectorOverlay*);
 
     void innerEnable();
     void notifyDocumentUpdated();
 
     void setSearchingForNode(ErrorString*, SearchMode, JSONObject* highlightConfig);
@@ skipping 13 matching lines @@
     int pushNodePathToFrontend(Node*);
     void pushChildNodesToFrontend(int nodeId, int depth = 1);
 
     void invalidateFrameOwnerElement(LocalFrame*);
 
     PassRefPtr<TypeBuilder::DOM::Node> buildObjectForNode(Node*, int depth, NodeToIdMap*);
     PassRefPtr<TypeBuilder::Array<String> > buildArrayForElementAttributes(Element*);
     PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap);
     PassRefPtr<TypeBuilder::DOM::EventListener> buildObjectForEventListener(const RegisteredEventListener&, const AtomicString& eventType, Node*, const String* objectGroupId);
     PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > buildArrayForPseudoElements(Element*, NodeToIdMap* nodesMap);
+    PassRefPtr<TypeBuilder::DOM::AnimationPlayer> buildObjectForAnimationPlayer(AnimationPlayer&);
+    PassRefPtr<TypeBuilder::DOM::AnimationNode> buildObjectForAnimationNode(AnimationNode&);
 
     Node* nodeForPath(const String& path);
 
     void discardFrontendBindings();
 
     void innerHighlightQuad(PassOwnPtr<FloatQuad>, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor);
 
     bool pushDocumentUponHandlelessOperation(ErrorString*);
 
+    static String playerId(AnimationPlayer& player) { return String::number(player.sequenceNumber()); }

[vsevik, 2014/10/14 09:08:08]

I don't think we should inline it.

[samli, 2014/10/15 08:46:44]

Done.

+
     RawPtrWillBeMember<InspectorPageAgent> m_pageAgent;
     RawPtrWillBeMember<InjectedScriptManager> m_injectedScriptManager;
     InspectorOverlay* m_overlay;
     InspectorFrontend::DOM* m_frontend;
     RawPtrWillBeMember<DOMListener> m_domListener;
     OwnPtrWillBeMember<NodeToIdMap> m_documentNodeToIdMap;
     // Owns node mappings for dangling nodes.
     WillBeHeapVector<OwnPtrWillBeMember<NodeToIdMap> > m_danglingNodeToIdMaps;
     WillBeHeapHashMap<int, RawPtrWillBeMember<Node> > m_idToNode;
     WillBeHeapHashMap<int, RawPtrWillBeMember<NodeToIdMap> > m_idToNodesMap;
     HashSet<int> m_childrenRequested;
     HashMap<int, int> m_cachedChildCount;
     int m_lastNodeId;
     RefPtrWillBeMember<Document> m_document;
     typedef WillBeHeapHashMap<String, WillBeHeapVector<RefPtrWillBeMember<Node> > > SearchResults;
     SearchResults m_searchResults;
     OwnPtrWillBeMember<RevalidateStyleAttributeTask> m_revalidateStyleAttrTask;
     SearchMode m_searchingForNode;
     OwnPtr<HighlightConfig> m_inspectModeHighlightConfig;
     OwnPtrWillBeMember<InspectorHistory> m_history;
     OwnPtrWillBeMember<DOMEditor> m_domEditor;
     bool m_suppressAttributeModifiedEvent;
     RawPtrWillBeMember<Listener> m_listener;
+    WillBeHeapHashMap<String, RefPtrWillBeMember<AnimationPlayer> > m_idToAnimationPlayer;
 };
 
 
 } // namespace blink
 
 #endif // !defined(InspectorDOMAgent_h)