Web Animations CSS: Add use counter analytics to CSSAnimations.

Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 24 matching lines @@
 #include "core/animation/ActiveAnimations.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/KeyframeAnimationEffect.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Element.h"
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/events/TransitionEvent.h"
 #include "core/events/WebKitAnimationEvent.h"
+#include "core/frame/UseCounter.h"
 #include "core/frame/animation/CSSPropertyAnimation.h"
 #include "core/platform/animation/CSSAnimationDataList.h"
 #include "core/platform/animation/TimingFunction.h"
 #include "core/rendering/style/KeyframeList.h"
+#include "public/platform/Platform.h"
 #include "wtf/HashSet.h"
 
 namespace WebCore {
 
 struct CandidateTransition {
     CandidateTransition(PassRefPtr<AnimatableValue> from, PassRefPtr<AnimatableValue> to, const CSSAnimationData* anim)
         : from(from)
         , to(to)
         , anim(anim)
     {
@@ skipping 187 matching lines @@
     ASSERT(RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     const StyleRuleKeyframes* keyframesRule = CSSAnimations::matchScopedKeyframesRule(resolver, element, name.impl());
     if (!keyframesRule)
         return;
 
     const Vector<RefPtr<StyleKeyframe> >& styleKeyframes = keyframesRule->keyframes();
     if (styleKeyframes.isEmpty())
         return;
 
     // Construct and populate the style for each keyframe
+    PropertySet specifiedProperties;
     KeyframeAnimationEffect::KeyframeVector keyframes;
     HashMap<double, RefPtr<TimingFunction> > perKeyframeTimingFunctions;
     for (size_t i = 0; i < styleKeyframes.size(); ++i) {
         const StyleKeyframe* styleKeyframe = styleKeyframes[i].get();
         RefPtr<RenderStyle> keyframeStyle = resolver->styleForKeyframe(element, style, styleKeyframe);
         RefPtr<Keyframe> keyframe = Keyframe::create();
         const Vector<double>& offsets = styleKeyframe->keys();
         ASSERT(!offsets.isEmpty());
         keyframe->setOffset(offsets[0]);
         TimingFunction* timingFunction = defaultTimingFunction;
         const StylePropertySet* properties = styleKeyframe->properties();
         for (unsigned j = 0; j < properties->propertyCount(); j++) {
             CSSPropertyID property = properties->propertyAt(j).id();
+            specifiedProperties.add(property);
             if (property == CSSPropertyWebkitAnimationTimingFunction || property == CSSPropertyAnimationTimingFunction) {
                 // FIXME: This sometimes gets the wrong timing function. See crbug.com/288540.
                 timingFunction = KeyframeValue::timingFunction(keyframeStyle.get(), name);
             } else if (CSSAnimations::isAnimatableProperty(property)) {
                 keyframe->setPropertyValue(property, CSSAnimatableValueFactory::create(property, keyframeStyle.get()).get());
             }
         }
         keyframes.append(keyframe);
         // The last keyframe specified at a given offset is used.
         perKeyframeTimingFunctions.set(offsets[0], timingFunction);
         for (size_t j = 1; j < offsets.size(); ++j) {
             keyframes.append(keyframe->cloneWithOffset(offsets[j]));
             perKeyframeTimingFunctions.set(offsets[j], timingFunction);
         }
     }
     ASSERT(!keyframes.isEmpty());
 
     if (!perKeyframeTimingFunctions.contains(0))
         perKeyframeTimingFunctions.set(0, defaultTimingFunction);
 
+    for (PropertySet::const_iterator iter = specifiedProperties.begin(); iter != specifiedProperties.end(); ++iter) {
+        const CSSPropertyID property = *iter;
+        ASSERT(property != CSSPropertyInvalid);
+        blink::Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(property));
+    }
+
     // Remove duplicate keyframes. In CSS the last keyframe at a given offset takes priority.
     std::stable_sort(keyframes.begin(), keyframes.end(), Keyframe::compareOffsets);
     size_t targetIndex = 0;
     for (size_t i = 1; i < keyframes.size(); i++) {
         if (keyframes[i]->offset() != keyframes[targetIndex]->offset())
             targetIndex++;
         if (targetIndex != i)
             keyframes[targetIndex] = keyframes[i];
     }
     keyframes.shrink(targetIndex + 1);
@@ skipping 232 matching lines @@
         runningTransition.from = newTransition.from;
         runningTransition.to = newTransition.to;
 
         CSSPropertyID id = newTransition.id;
         InertAnimation* inertAnimation = newTransition.animation.get();
         OwnPtr<TransitionEventDelegate> eventDelegate = adoptPtr(new TransitionEventDelegate(element, id));
         RefPtr<Animation> transition = Animation::create(element, inertAnimation->effect(), inertAnimation->specified(), Animation::TransitionPriority, eventDelegate.release());
         element->document().transitionTimeline()->play(transition.get());
         runningTransition.transition = transition.get();
         m_transitions.set(id, runningTransition);
+        ASSERT(id != CSSPropertyInvalid);
+        blink::Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
     }
 }
 
 void CSSAnimations::calculateTransitionUpdateForProperty(CSSAnimationUpdate* update, CSSPropertyID id, const CandidateTransition& newTransition, const TransitionMap* existingTransitions)
 {
     if (existingTransitions) {
         TransitionMap::const_iterator existingTransitionIter = existingTransitions->find(id);
 
         if (existingTransitionIter != existingTransitions->end() && !update->cancelledTransitions().contains(id)) {
             const AnimatableValue* existingTo = existingTransitionIter->value.to;
@@ skipping 314 matching lines @@
             CSSPropertyID id = convertToCSSPropertyID(i);
             if (isAnimatableProperty(id))
                 properties.append(id);
         }
         propertyShorthand = StylePropertyShorthand(CSSPropertyInvalid, properties.begin(), properties.size());
     }
     return propertyShorthand;
 }
 
 } // namespace WebCore