Move CSS animations use counters to UseCounter

third_party/WebKit/Source/core/frame/UseCounter.cpp

 /*
  * Copyright (C) 2012 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1083 matching lines @@
 
   ASSERT_NOT_REACHED();
   return 0;
 }
 
 UseCounter::UseCounter(Context context)
     : m_muteCount(0),
       m_disableReporting(false),
       m_context(context),
       m_featuresRecorded(NumberOfFeatures),
-      m_CSSRecorded(numCSSPropertyIDs) {}
+      m_CSSRecorded(numCSSPropertyIDs),
+      m_animatedCSSRecorded(numCSSPropertyIDs) {}
 
 void UseCounter::muteForInspector() {
   m_muteCount++;
 }
 
 void UseCounter::unmuteForInspector() {
   m_muteCount--;
 }
 
 void UseCounter::recordMeasurement(Feature feature) {
@@ skipping 44 matching lines @@
   // Use the protocol of the document being loaded into the main frame to
   // decide whether this page is interesting from a metrics perspective.
   // Note that SVGImage cases always have an about:blank URL
   if (m_context == DefaultContext &&
       !SchemeRegistry::shouldTrackUsageMetricsForScheme(url.protocol())) {
     m_disableReporting = true;
   }
 
   m_featuresRecorded.clearAll();
   m_CSSRecorded.clearAll();
+  m_animatedCSSRecorded.clearAll();
   if (!m_disableReporting && !m_muteCount) {
     featuresHistogram().count(PageVisits);
     cssHistogram().count(totalPagesMeasuredCSSSampleId());
+    animatedCSSHistogram().count(totalPagesMeasuredCSSSampleId());
   }
 }
 
 void UseCounter::count(const Frame* frame, Feature feature) {
   if (!frame)
     return;
   Page* page = frame->page();
   if (!page)
     return;
 
@@ skipping 43 matching lines @@
 }
 
 void UseCounter::countCrossOriginIframe(const Document& document,
                                         Feature feature) {
   LocalFrame* frame = document.frame();
   if (frame && frame->isCrossOriginSubframe())
     count(frame, feature);
 }
 
 void UseCounter::count(CSSParserMode cssParserMode, CSSPropertyID property) {
+  // FIXME(suzyh): Count custom properties as well as named properties
   DCHECK(isCSSPropertyIDWithName(property));
 
   if (!isUseCounterEnabledForMode(cssParserMode) || m_muteCount)
     return;
 
   if (!m_CSSRecorded.quickGet(property)) {
     // Note that HTTPArchive tooling looks specifically for this event - see
     // https://github.com/HTTPArchive/httparchive/issues/59
     int sampleId = mapCSSPropertyIdToCSSSampleIdForHistogram(property);
     if (!m_disableReporting) {
       TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
                    "CSSFirstUsed", "feature", sampleId);
       cssHistogram().count(sampleId);
     }
     m_CSSRecorded.quickSet(property);
   }
   m_legacyCounter.countCSS(property);
 }
 
 void UseCounter::count(Feature feature) {
   recordMeasurement(feature);
 }
 
+bool UseCounter::isCountedAnimatedCSS(CSSPropertyID unresolvedProperty) {
+  return m_animatedCSSRecorded.quickGet(unresolvedProperty);
+}
+
+bool UseCounter::isCountedAnimatedCSS(Document& document,
+                                      const String& string) {
+  Page* page = document.page();
+  if (!page)
+    return false;
+
+  CSSPropertyID unresolvedProperty = unresolvedCSSPropertyID(string);
+  if (unresolvedProperty == CSSPropertyInvalid)
+    return false;
+  return page->useCounter().isCountedAnimatedCSS(unresolvedProperty);
+}
+
+void UseCounter::countAnimatedCSS(const Document& document,
+                                  CSSPropertyID property) {
+  Page* page = document.page();
+  if (!page)
+    return;
+
+  page->useCounter().countAnimatedCSS(property);
+}
+
+void UseCounter::countAnimatedCSS(CSSPropertyID property) {
+  DCHECK(isCSSPropertyIDWithName(property) || property == CSSPropertyVariable);
+
+  if (m_muteCount)
+    return;
+
+  if (!m_animatedCSSRecorded.quickGet(property)) {
+    int sampleId = mapCSSPropertyIdToCSSSampleIdForHistogram(property);
+    if (!m_disableReporting) {
+      TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
+                   "AnimatedCSSFirstUsed", "feature", sampleId);
+      animatedCSSHistogram().count(sampleId);
+    }
+    m_animatedCSSRecorded.quickSet(property);
+  }
+}
+
 void UseCounter::notifyFeatureCounted(Feature feature) {
   DCHECK(!m_muteCount);
   DCHECK(!m_disableReporting);
   HeapHashSet<Member<Observer>> toBeRemoved;
   for (auto observer : m_observers) {
     if (observer->onCountFeature(feature))
       toBeRemoved.insert(observer);
   }
   m_observers.removeAll(toBeRemoved);
 }
@@ skipping 18 matching lines @@
 EnumerationHistogram& UseCounter::cssHistogram() const {
   DEFINE_STATIC_LOCAL(blink::EnumerationHistogram, histogram,
                       ("Blink.UseCounter.CSSProperties", kMaximumCSSSampleId));
   DEFINE_STATIC_LOCAL(
       blink::EnumerationHistogram, svgHistogram,
       ("Blink.UseCounter.SVGImage.CSSProperties", kMaximumCSSSampleId));
 
   return m_context == SVGImageContext ? svgHistogram : histogram;
 }
 
+EnumerationHistogram& UseCounter::animatedCSSHistogram() const {
+  DEFINE_STATIC_LOCAL(
+      blink::EnumerationHistogram, histogram,
+      ("Blink.UseCounter.AnimatedCSSProperties", kMaximumCSSSampleId));
+  DEFINE_STATIC_LOCAL(
+      blink::EnumerationHistogram, svgHistogram,
+      ("Blink.UseCounter.SVGImage.AnimatedCSSProperties", kMaximumCSSSampleId));
+
+  return m_context == SVGImageContext ? svgHistogram : histogram;
+}
+
 /*
  *
  * LEGACY metrics support - WebCore.FeatureObserver is to be superceded by
  * WebCore.UseCounter
  *
  */
 
 static EnumerationHistogram& featureObserverHistogram() {
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, histogram,
@@ skipping 45 matching lines @@
     }
   }
 
   if (needsPagesMeasuredUpdate)
     cssPropertiesHistogram.count(totalPagesMeasuredCSSSampleId());
 
   m_CSSBits.clearAll();
 }
 
 }  // namespace blink