Mute use counters for internal pages

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 19 matching lines @@
 #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/WorkerOrWorkletGlobalScope.h"
 #include "platform/Histogram.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
+#include "platform/weborigin/SchemeRegistry.h"
 
 namespace {
 
 int totalPagesMeasuredCSSSampleId() {
   return 1;
 }
 
 // Make sure update_use_counter_css.py was run which updates histograms.xml.
 constexpr int kMaximumCSSSampleId = 549;
 
@@ skipping 1026 matching lines @@
       ASSERT_NOT_REACHED();
       return 0;
   }
 
   ASSERT_NOT_REACHED();
   return 0;
 }
 
 UseCounter::UseCounter(Context context)
     : m_muteCount(0),
+      m_disableReporting(false),
       m_context(context),
       m_featuresRecorded(NumberOfFeatures),
       m_CSSRecorded(lastUnresolvedCSSProperty + 1) {}
 
 void UseCounter::muteForInspector() {
   m_muteCount++;
 }
 
 void UseCounter::unmuteForInspector() {
   m_muteCount--;
 }
 
 void UseCounter::recordMeasurement(Feature feature) {
   if (m_muteCount)
     return;
 
   DCHECK(feature != OBSOLETE_PageDestruction &&
          feature !=
              PageVisits);  // PageDestruction is reserved as a scaling factor.
   DCHECK(feature < NumberOfFeatures);
 
   if (!m_featuresRecorded.quickGet(feature)) {
     // Note that HTTPArchive tooling looks specifically for this event - see
     // https://github.com/HTTPArchive/httparchive/issues/59
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
-                 "FeatureFirstUsed", "feature", feature);
-    featuresHistogram().count(feature);
+    if (!m_disableReporting) {
+      TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
+                   "FeatureFirstUsed", "feature", feature);
+      featuresHistogram().count(feature);
+    }
     m_featuresRecorded.quickSet(feature);
   }
   m_legacyCounter.countFeature(feature);
 }
 
 bool UseCounter::hasRecordedMeasurement(Feature feature) const {
   if (m_muteCount)
     return false;
 
   DCHECK(feature != OBSOLETE_PageDestruction &&
          feature !=
              PageVisits);  // PageDestruction is reserved as a scaling factor.
   DCHECK(feature < NumberOfFeatures);
 
   return m_featuresRecorded.quickGet(feature);
 }
 
-void UseCounter::didCommitLoad() {
+void UseCounter::didCommitLoad(KURL url) {
   m_legacyCounter.updateMeasurements();
 
-  // TODO: Is didCommitLoad really the right time to do this?  crbug.com/608040
+  // Reset state from previous load.
+  m_disableReporting = false;
+
+  // 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();
-  featuresHistogram().count(PageVisits);
   m_CSSRecorded.clearAll();
-  cssHistogram().count(totalPagesMeasuredCSSSampleId());
+  if (!m_disableReporting && !m_muteCount) {
+    featuresHistogram().count(PageVisits);
+    cssHistogram().count(totalPagesMeasuredCSSSampleId());
+  }
 }
 
 void UseCounter::count(const Frame* frame, Feature feature) {
   if (!frame)
     return;
   FrameHost* host = frame->host();
   if (!host)
     return;
 
   host->useCounter().count(feature);
@@ skipping 52 matching lines @@
 void UseCounter::count(CSSParserMode cssParserMode, CSSPropertyID property) {
   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);
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
-                 "CSSFirstUsed", "feature", sampleId);
-    cssHistogram().count(sampleId);
+    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) {
   DCHECK(Deprecation::deprecationMessage(feature).isEmpty());
   recordMeasurement(feature);
 }
 
@@ skipping 11 matching lines @@
 
 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;
 }
 
 EnumerationHistogram& UseCounter::featuresHistogram() const {
-  // TODO(rbyers): Fix the SVG case.  crbug.com/236262
-  // Eg. every SVGImage has it's own Page instance, they should probably all be
-  // delegating their UseCounter to the containing Page.  For now just use a
-  // separate histogram.
+  // Every SVGImage has it's own Page instance, and multiple web pages can
+  // share the usage of a single SVGImage.  Ideally perhaps we'd delegate
+  // metrics from an SVGImage to one of the Page's it's displayed in, but
+  // that's tricky (SVGImage is intentionally isolated, and the Page that
+  // created it may not even exist anymore).
+  // So instead we just use a dedicated histogram for the SVG case.
   DEFINE_STATIC_LOCAL(blink::EnumerationHistogram, histogram,
                       ("WebCore.UseCounter_TEST.Features",
                        blink::UseCounter::NumberOfFeatures));
   DEFINE_STATIC_LOCAL(blink::EnumerationHistogram, svgHistogram,
                       ("WebCore.UseCounter_TEST.SVGImage.Features",
                        blink::UseCounter::NumberOfFeatures));
 
   return m_context == SVGImageContext ? svgHistogram : histogram;
 }
 
@@ skipping 67 matching lines @@
     }
   }
 
   if (needsPagesMeasuredUpdate)
     cssPropertiesHistogram.count(totalPagesMeasuredCSSSampleId());
 
   m_CSSBits.clearAll();
 }
 
 }  // namespace blink