Added trace events for blink feature usage

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 18 matching lines @@
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/Histogram.h"
+#include "platform/TraceEvent.h"
 
 namespace blink {
 
 static int totalPagesMeasuredCSSSampleId() { return 1; }
 
 int UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(int id)
 {
     CSSPropertyID cssPropertyID = static_cast<CSSPropertyID>(id);
 
     switch (cssPropertyID) {
@@ skipping 607 matching lines @@
 
 void UseCounter::count(const Frame* frame, Feature feature)
 {
     if (!frame)
         return;
     FrameHost* host = frame->host();
     if (!host)
         return;
 
     ASSERT(Deprecation::deprecationMessage(feature).isEmpty());
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"), "FeatureUsed", "feature", feature);

[Rick Byers, 2016/08/03 01:08:32]

I believe this will double count (Calls into the one below that you've also
instrumented).

[Pat Meenan, 2016/08/03 13:20:27]

It doesn't because it is calling directly into recordMeasurement() instead of
count().

Instead of duplicating the functionality of count() below up here as well I just
changed it to call into count() instead (and removed the ASSERT since count()
does that as well).

     host->useCounter().recordMeasurement(feature);
 }
 
 void UseCounter::count(const Document& document, Feature feature)
 {
     count(document.frame(), feature);
 }
 
 bool UseCounter::isCounted(Document& document, Feature feature)
 {
@@ skipping 68 matching lines @@
 }
 
 void UseCounter::count(CSSParserMode cssParserMode, CSSPropertyID feature)
 {
     ASSERT(feature >= firstCSSProperty);
     ASSERT(feature <= lastUnresolvedCSSProperty);
 
     if (!isUseCounterEnabledForMode(cssParserMode) || m_muteCount)
         return;
 
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"), "FeatureUsed", "feature", feature);

[Rick Byers, 2016/08/03 01:08:32]

This 'feature' has a different range/semantics than the others (CSSPropertyID
instead of UseCounter enum).  Name it "CSSFeatureUsed" instead?

[Pat Meenan, 2016/08/03 13:20:27]

Doh.  Good catch, thanks.  Done.

     m_CSSFeatureBits.quickSet(feature);
 }
 
 void UseCounter::count(Feature feature)
 {
     ASSERT(Deprecation::deprecationMessage(feature).isEmpty());
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"), "FeatureUsed", "feature", feature);

[Rick Byers, 2016/08/03 01:08:32]

There are a few features which are used a LOT, do you really want EACH usage in
the trace?  That could really bloat the trace when this is enabled.  I think it
would probably be fine to check hasRecordedMeasurement first and only do the
trace when it's not already true (so reporting the first usage per page load). 
WDYT?

[Pat Meenan, 2016/08/03 13:20:27]

Is there value in knowing how often features were used on a given page?  At
least for the HTTP Archive/WPT I was going to count the occurrences of each
feature recorded (and convert everything to strings).

The actual memory use is small since it is just recording the pointers for the
name and the enum (and the trace timestamp info) and it is only when this
category is explicitly turned on.  I did some browsing while testing and even
the v8 modes which fire a LOT (at least on the sites I was testing) still
resulted in <10k events on some of the more painful pages and well under 5% of
the default buffer (and ~1MB as gz json).

By measuring each occurrence we could also do arbitration for certain features
if it became interesting.

It could be that I also didn't hit a pathological case so I could easily be
convinced to limit it to the first occurrence or maybe to treat CSS features and
regular features differently.

     recordMeasurement(feature);
 }
 
 UseCounter* UseCounter::getFrom(const Document* document)
 {
     if (document && document->frameHost())
         return &document->frameHost()->useCounter();
     return 0;
 }
 
 UseCounter* UseCounter::getFrom(const CSSStyleSheet* sheet)
 {
     if (sheet)
         return getFrom(sheet->contents());
     return 0;
 }
 
 UseCounter* UseCounter::getFrom(const StyleSheetContents* sheetContents)
 {
     // FIXME: We may want to handle stylesheets that have multiple owners
     //        https://crbug.com/242125
     if (sheetContents && sheetContents->hasSingleOwnerNode())
         return getFrom(sheetContents->singleOwnerDocument());
     return 0;
 }
 
 } // namespace blink