Devtools Animations: Add method to fetch CSS keyframed animations

third_party/WebKit/Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 26 matching lines @@
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/InvalidatableStyleInterpolation.h"
 #include "core/animation/KeyframeEffect.h"
 #include "core/animation/StyleInterpolation.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSFontSelector.h"
+#include "core/css/CSSImportRule.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/FontFace.h"
@@ skipping 816 matching lines @@
     collector.setMode(SelectorChecker::CollectingCSSRules);
     collectPseudoRulesForElement(element, collector, pseudoId, rulesToInclude);
     return collector.matchedCSSRuleList();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::cssRulesForElement(Element* element, unsigned rulesToInclude)
 {
     return pseudoCSSRulesForElement(element, NOPSEUDO, rulesToInclude);
 }
 
+PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::keyframesRulesForElement(Element* element)
+{
+    ASSERT(element);
+    RefPtrWillBeRawPtr<StaticCSSRuleList> ruleList = StaticCSSRuleList::create();
+
+    // TODO(samli): Repeat for all pseudo elements.
+    RefPtr<ComputedStyle> style = styleForElement(element);
+    if (!style)
+        return ruleList;
+    const CSSAnimationData* animationData = style->animations();
+    for (size_t i = 0; animationData && i < animationData->nameList().size(); ++i) {
+        AtomicString animationName(animationData->nameList()[i]);
+        if (animationName == CSSAnimationData::initialName())
+            continue;
+        RefPtrWillBeRawPtr<CSSKeyframesRule> keyframesRule = findCSSKeyframesRule(element, animationName);

[alancutter (OOO until 2018), 2015/10/15 00:11:53]

It seems like a lot of added complexity to find the existing wrappers. Can we
just create new CSSOM wrappers for the @keyframes rules?

[samli, 2015/10/15 00:16:07]

Yes but with one caveat. I think when we later have the source ranges, devtools
won't be able to respond to CSSOM changes if we have a different wrapper.
lushnikov@, is that right?

Even so, its probably enough of an edge case that we could do that instead.

+        if (!keyframesRule)
+            continue;
+        ruleList->rules().append(keyframesRule);
+    }
+    return ruleList;
+}
+
 void StyleResolver::collectPseudoRulesForElement(Element* element, ElementRuleCollector& collector, PseudoId pseudoId, unsigned rulesToInclude)
 {
     collector.setPseudoStyleRequest(PseudoStyleRequest(pseudoId));
 
     if (rulesToInclude & UAAndUserCSSRules)
         matchUARules(collector);
 
     if (rulesToInclude & AuthorCSSRules) {
         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
         matchAuthorRules(element, collector, rulesToInclude & EmptyCSSRules);
@@ skipping 53 matching lines @@
     if (ScopedStyleResolver* scopedResolver = element->treeScope().scopedStyleResolver())
         resolvers.append(scopedResolver);
 
     for (size_t i = 0; i < resolvers.size(); ++i) {
         if (StyleRuleKeyframes* keyframesRule = resolvers[i]->keyframeStylesForAnimation(animationName.impl()))
             return keyframesRule;
     }
     return nullptr;
 }
 
+CSSKeyframesRule* StyleResolver::findCSSKeyframesRule(const Element* element, const AtomicString& animationName)
+{
+    WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8> resolvers;
+    collectScopedResolversForHostedShadowTrees(element, resolvers);
+    if (ScopedStyleResolver* scopedResolver = element->treeScope().scopedStyleResolver())
+        resolvers.append(scopedResolver);
+
+    for (size_t i = 0; i < resolvers.size(); ++i) {
+        if (StyleRuleKeyframes* keyframesRule = resolvers[i]->keyframeStylesForAnimation(animationName.impl())) {
+            CSSStyleSheet* styleSheet = resolvers[i]->styleSheetForAnimation(animationName.impl());
+            if (!styleSheet)
+                continue;
+            return findCSSKeyframesRule(styleSheet->cssRules(), keyframesRule);
+        }
+    }
+    return nullptr;
+}
+
+CSSKeyframesRule* StyleResolver::findCSSKeyframesRule(PassRefPtrWillBeRawPtr<CSSRuleList> cssRules, StyleRuleKeyframes* keyframesRule)
+{
+    if (!cssRules)
+        return nullptr;
+    CSSKeyframesRule* result = 0;
+    for (unsigned i = 0; i < cssRules->length() && !result; ++i) {
+        CSSRule* cssRule = cssRules->item(i);
+        CSSRule::Type cssRuleType = cssRule->type();
+        if (cssRuleType == CSSRule::KEYFRAMES_RULE) {
+            CSSKeyframesRule* cssKeyframesRule = toCSSKeyframesRule(cssRule);
+            if (cssKeyframesRule->keyframesRule() == keyframesRule)
+                return cssKeyframesRule;
+        } else if (cssRuleType == CSSRule::IMPORT_RULE) {
+            CSSImportRule* cssImportRule = toCSSImportRule(cssRule);
+            result = findCSSKeyframesRule(cssImportRule->styleSheet()->cssRules(), keyframesRule);
+        } else if (cssRuleType != CSSRule::STYLE_RULE) {
+            result = findCSSKeyframesRule(cssRule->cssRules(), keyframesRule);
+        }
+    }
+    return result;
+}
+
 template <CSSPropertyPriority priority>
 void StyleResolver::applyAnimatedProperties(StyleResolverState& state, const ActiveInterpolationsMap& activeInterpolationsMap)
 {
     for (const auto& interpolationsVectorEntry : activeInterpolationsMap) {
         if (!interpolationsVectorEntry.key.isCSSProperty())
             continue;
         CSSPropertyID property = interpolationsVectorEntry.key.cssProperty();
         if (!CSSPropertyPriorityData<priority>::propertyHasPriority(property))
             continue;
         const Interpolation& interpolation = *interpolationsVectorEntry.value.first();
@@ skipping 521 matching lines @@
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleResourceLoader);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink