Adding UseCounter specific for extensions

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "core/page/Page.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/testing/HistogramTester.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
-const char* const kFeaturesHistogramName = "Blink.UseCounter.Features";
-const char* const kCSSHistogramName = "Blink.UseCounter.CSSProperties";
-const char* const kAnimatedCSSHistogramName =
+const char kFeaturesHistogramName[] = "Blink.UseCounter.Features";
+const char kCSSHistogramName[] = "Blink.UseCounter.CSSProperties";
+const char kAnimatedCSSHistogramName[] =
     "Blink.UseCounter.AnimatedCSSProperties";
+const char kExtensionFeaturesHistogramName[] =
+    "Blink.UseCounter.Extensions.Features";
 
-const char* const kSVGFeaturesHistogramName =
-    "Blink.UseCounter.SVGImage.Features";
-const char* const kSVGCSSHistogramName =
-    "Blink.UseCounter.SVGImage.CSSProperties";
-const char* const kSVGAnimatedCSSHistogramName =
+const char kSVGFeaturesHistogramName[] = "Blink.UseCounter.SVGImage.Features";
+const char kSVGCSSHistogramName[] = "Blink.UseCounter.SVGImage.CSSProperties";
+const char kSVGAnimatedCSSHistogramName[] =
     "Blink.UseCounter.SVGImage.AnimatedCSSProperties";
 
-const char* const kLegacyFeaturesHistogramName = "WebCore.FeatureObserver";
-const char* const kLegacyCSSHistogramName =
-    "WebCore.FeatureObserver.CSSProperties";
+const char kLegacyFeaturesHistogramName[] = "WebCore.FeatureObserver";
+const char kLegacyCSSHistogramName[] = "WebCore.FeatureObserver.CSSProperties";
+
+// In practice, SVGs always appear to be loaded with an about:blank URL
+const char kSvgUrl[] = "about:blank";
+const char* const kInternalUrl = kSvgUrl;
+const char kHttpsUrl[] = "https://dummysite.com/";
+const char kExtensionUrl[] = "chrome-extension://dummysite/";
+
+int GetPageVisitsBucketforHistogram(const std::string& histogram_name) {
+  if (histogram_name.find("CSS") == std::string::npos)
+    return blink::UseCounter::kPageVisits;
+  // For CSS histograms, the page visits bucket should be 1.
+  return 1;
 }
 
+}  // namespace
+
 namespace blink {
 
 template <typename T>
 void HistogramBasicTest(const std::string& histogram,
                         const std::string& legacy_histogram,
-                        const std::vector<std::string>& unaffected_histograms,
                         T item,
                         T second_item,
                         std::function<bool(T)> counted,
                         std::function<void(T)> count,
                         std::function<int(T)> histogram_map,
                         std::function<void(KURL)> did_commit_load,
-                        const std::string& url,
-                        int page_visit_bucket) {
+                        const std::string& url) {
   HistogramTester histogram_tester;
 
+  int page_visit_bucket = GetPageVisitsBucketforHistogram(histogram);
+
   // Test recording a single (arbitrary) counter
   EXPECT_FALSE(counted(item));
   count(item);
   EXPECT_TRUE(counted(item));
   histogram_tester.ExpectUniqueSample(histogram, histogram_map(item), 1);
   if (!legacy_histogram.empty()) {
     histogram_tester.ExpectTotalCount(legacy_histogram, 0);
   }
 
   // Test that repeated measurements have no effect
@@ skipping 44 matching lines @@
   did_commit_load(URLTestHelpers::ToKURL(url));
   if (!legacy_histogram.empty()) {
     histogram_tester.ExpectBucketCount(legacy_histogram, histogram_map(item),
                                        2);
     histogram_tester.ExpectBucketCount(legacy_histogram,
                                        histogram_map(second_item), 1);
     histogram_tester.ExpectBucketCount(legacy_histogram, page_visit_bucket, 2);
     histogram_tester.ExpectTotalCount(legacy_histogram, 5);
   }
 
-  for (size_t i = 0; i < unaffected_histograms.size(); ++i) {
-    histogram_tester.ExpectTotalCount(unaffected_histograms[i], 0);
+  // For all histograms, no other histograms besides |histogram| should
+  // be affected. Legacy histograms are not included in the list because they
+  // soon will be removed.
+  for (const auto& unaffected_histogram :
+       {kAnimatedCSSHistogramName, kCSSHistogramName,
+        kExtensionFeaturesHistogramName, kFeaturesHistogramName,
+        kSVGAnimatedCSSHistogramName, kSVGCSSHistogramName,
+        kSVGFeaturesHistogramName}) {
+    if (unaffected_histogram == histogram)
+      continue;
+
+    // The expected total count for unaffected histograms should be either:
+    //    a. 0, for "non-CSS" histograms (their "page visits" bucket should be
+    //      empty); or
+    //    b. The value of the "page visits" bucket, for "CSS" histograms.

[Rick Byers, 2017/05/12 17:51:21]

nit: This comment seems slightly wrong.  Rather than being about "non-CSS" and
"CSS" isn't it really about histograms that are for the same or different
context than the one under test?

Eg. when testing "Features", "CSSFeatures" will have a total count equal to
pageVisits, but "SVGImage.CSSFeatures" will have a total count of 0 (since there
no SVG images loaded at all).

[lunalu1, 2017/05/15 14:34:28]

Done.

+    histogram_tester.ExpectTotalCount(
+        unaffected_histogram,
+        0 + histogram_tester.GetBucketCount(
+                unaffected_histogram,
+                GetPageVisitsBucketforHistogram(unaffected_histogram)));
   }
 }
 
 TEST(UseCounterTest, RecordingFeatures) {
   UseCounter use_counter;
   HistogramBasicTest<UseCounter::Feature>(
-      kFeaturesHistogramName, kLegacyFeaturesHistogramName,
-      {kSVGFeaturesHistogramName, kSVGCSSHistogramName,
-       kSVGAnimatedCSSHistogramName},
-      UseCounter::kFetch, UseCounter::kFetchBodyStream,
+      kFeaturesHistogramName, kLegacyFeaturesHistogramName, UseCounter::kFetch,
+      UseCounter::kFetchBodyStream,
       [&](UseCounter::Feature feature) -> bool {
         return use_counter.HasRecordedMeasurement(feature);
       },
       [&](UseCounter::Feature feature) {
         use_counter.RecordMeasurement(feature);
       },
       [](UseCounter::Feature feature) -> int { return feature; },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); },
-      "https://dummysite.com/", UseCounter::kPageVisits);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kHttpsUrl);
 }
 
 TEST(UseCounterTest, RecordingCSSProperties) {
   UseCounter use_counter;
   HistogramBasicTest<CSSPropertyID>(
-      kCSSHistogramName, kLegacyCSSHistogramName,
-      {kSVGFeaturesHistogramName, kSVGCSSHistogramName,
-       kSVGAnimatedCSSHistogramName},
-      CSSPropertyFont, CSSPropertyZoom,
+      kCSSHistogramName, kLegacyCSSHistogramName, CSSPropertyFont,
+      CSSPropertyZoom,
       [&](CSSPropertyID property) -> bool {
         return use_counter.IsCounted(property);
       },
       [&](CSSPropertyID property) {
         use_counter.Count(kHTMLStandardMode, property);
       },
       [](CSSPropertyID property) -> int {
         return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
       },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); },
-      "https://dummysite.com/", 1 /* page visit bucket */);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kHttpsUrl);
 }
 
 TEST(UseCounterTest, RecordingAnimatedCSSProperties) {
   UseCounter use_counter;
   HistogramBasicTest<CSSPropertyID>(
-      kAnimatedCSSHistogramName, "",
-      {kSVGCSSHistogramName, kSVGAnimatedCSSHistogramName}, CSSPropertyOpacity,
-      CSSPropertyVariable,
+      kAnimatedCSSHistogramName, "", CSSPropertyOpacity, CSSPropertyVariable,
       [&](CSSPropertyID property) -> bool {
         return use_counter.IsCountedAnimatedCSS(property);
       },
       [&](CSSPropertyID property) { use_counter.CountAnimatedCSS(property); },
       [](CSSPropertyID property) -> int {
         return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
       },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); },
-      "https://dummysite.com/", 1 /* page visit bucket */);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kHttpsUrl);
+}
+
+TEST(UseCounterTest, RecordingExtensions) {
+  UseCounter use_counter(UseCounter::kExtensionContext);
+  HistogramBasicTest<UseCounter::Feature>(
+      kExtensionFeaturesHistogramName, kLegacyFeaturesHistogramName,
+      UseCounter::kFetch, UseCounter::kFetchBodyStream,
+      [&](UseCounter::Feature feature) -> bool {
+        return use_counter.HasRecordedMeasurement(feature);
+      },
+      [&](UseCounter::Feature feature) {
+        use_counter.RecordMeasurement(feature);
+      },
+      [](UseCounter::Feature feature) -> int { return feature; },
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kExtensionUrl);
 }
 
 TEST(UseCounterTest, SVGImageContextFeatures) {
   UseCounter use_counter(UseCounter::kSVGImageContext);
   HistogramBasicTest<UseCounter::Feature>(
       kSVGFeaturesHistogramName, kLegacyFeaturesHistogramName,
-      {kFeaturesHistogramName, kCSSHistogramName, kAnimatedCSSHistogramName},
       UseCounter::kSVGSMILAdditiveAnimation,
       UseCounter::kSVGSMILAnimationElementTiming,
       [&](UseCounter::Feature feature) -> bool {
         return use_counter.HasRecordedMeasurement(feature);
       },
       [&](UseCounter::Feature feature) {
         use_counter.RecordMeasurement(feature);
       },
       [](UseCounter::Feature feature) -> int { return feature; },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, "about:blank",
-      // In practice SVGs always appear to be loaded with an about:blank URL
-      UseCounter::kPageVisits);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kSvgUrl);
 }
 
 TEST(UseCounterTest, SVGImageContextCSSProperties) {
   UseCounter use_counter(UseCounter::kSVGImageContext);
   HistogramBasicTest<CSSPropertyID>(
-      kSVGCSSHistogramName, kLegacyCSSHistogramName,
-      {kFeaturesHistogramName, kCSSHistogramName, kAnimatedCSSHistogramName},
-      CSSPropertyFont, CSSPropertyZoom,
+      kSVGCSSHistogramName, kLegacyCSSHistogramName, CSSPropertyFont,
+      CSSPropertyZoom,
       [&](CSSPropertyID property) -> bool {
         return use_counter.IsCounted(property);
       },
       [&](CSSPropertyID property) {
         use_counter.Count(kHTMLStandardMode, property);
       },
       [](CSSPropertyID property) -> int {
         return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
       },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, "about:blank",
-      // In practice SVGs always appear to be loaded with an about:blank URL
-      1 /* page visit bucket */);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kSvgUrl);
 }
 
 TEST(UseCounterTest, SVGImageContextAnimatedCSSProperties) {
   UseCounter use_counter(UseCounter::kSVGImageContext);
   HistogramBasicTest<CSSPropertyID>(
-      kSVGAnimatedCSSHistogramName, "",
-      {kCSSHistogramName, kAnimatedCSSHistogramName}, CSSPropertyOpacity,
-      CSSPropertyVariable,
+      kSVGAnimatedCSSHistogramName, "", CSSPropertyOpacity, CSSPropertyVariable,
       [&](CSSPropertyID property) -> bool {
         return use_counter.IsCountedAnimatedCSS(property);
       },
       [&](CSSPropertyID property) { use_counter.CountAnimatedCSS(property); },
       [](CSSPropertyID property) -> int {
         return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
       },
-      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, "about:blank",
-      // In practice SVGs always appear to be loaded with an about:blank URL
-      1 /* page visit bucket */);
+      [&](KURL kurl) { use_counter.DidCommitLoad(kurl); }, kSvgUrl);
 }
 
 TEST(UseCounterTest, InspectorDisablesMeasurement) {
   UseCounter use_counter;
   HistogramTester histogram_tester;
 
   // The specific feature we use here isn't important.
   UseCounter::Feature feature = UseCounter::Feature::kSVGSMILElementInDocument;
   CSSPropertyID property = CSSPropertyFontWeight;
   CSSParserMode parser_mode = kHTMLStandardMode;
@@ skipping 60 matching lines @@
   UseCounter use_counter;
   HistogramTester histogram_tester;
 
   // Counters triggered before any load are always reported.
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 0, UseCounter::kFetch, 1,
                    CSSPropertyFontWeight, 1);
 
   // Loading an internal page doesn't bump PageVisits and metrics not reported.
-  use_counter.DidCommitLoad(URLTestHelpers::ToKURL("about:blank"));
+  use_counter.DidCommitLoad(URLTestHelpers::ToKURL(kInternalUrl));
   EXPECT_FALSE(use_counter.HasRecordedMeasurement(UseCounter::kFetch));
   EXPECT_FALSE(use_counter.IsCounted(CSSPropertyFontWeight));
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 0, UseCounter::kFetch, 1,
                    CSSPropertyFontWeight, 1);
 
   // But the fact that the features were seen is still known.
   EXPECT_TRUE(use_counter.HasRecordedMeasurement(UseCounter::kFetch));
   EXPECT_TRUE(use_counter.IsCounted(CSSPropertyFontWeight));
 
   // Inspector muting then unmuting doesn't change the behavior.
   use_counter.MuteForInspector();
   use_counter.UnmuteForInspector();
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 0, UseCounter::kFetch, 1,
                    CSSPropertyFontWeight, 1);
 
   // If we now load a real web page, metrics are reported again.
   use_counter.DidCommitLoad(URLTestHelpers::ToKURL("http://foo.com/"));
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 1, UseCounter::kFetch, 2,
                    CSSPropertyFontWeight, 2);
 
   // HTTPs URLs are the same.
-  use_counter.DidCommitLoad(
-      URLTestHelpers::ToKURL("https://baz.com:1234/blob.html"));
+  use_counter.DidCommitLoad(URLTestHelpers::ToKURL(kHttpsUrl));
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 2, UseCounter::kFetch, 3,
                    CSSPropertyFontWeight, 3);
 
   // Extensions aren't counted.
-  use_counter.DidCommitLoad(
-      URLTestHelpers::ToKURL("chrome-extension://1238ba908adf/"));
+  use_counter.DidCommitLoad(URLTestHelpers::ToKURL(kExtensionUrl));
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
   ExpectHistograms(histogram_tester, 2, UseCounter::kFetch, 3,
                    CSSPropertyFontWeight, 3);
 
   // Nor is devtools
   use_counter.DidCommitLoad(
       URLTestHelpers::ToKURL("chrome-devtools://1238ba908adf/"));
   use_counter.RecordMeasurement(UseCounter::kFetch);
   use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
@@ skipping 65 matching lines @@
 
   deprecation_.UnmuteForInspector();
   Deprecation::WarnOnDeprecatedProperties(GetFrame(), property);
   // TODO: use the actually deprecated property to get a deprecation message.
   EXPECT_FALSE(deprecation_.IsSuppressed(property));
   Deprecation::CountDeprecation(GetFrame(), feature);
   EXPECT_TRUE(use_counter_.HasRecordedMeasurement(feature));
 }
 
 }  // namespace blink