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/RuntimeEnabledFeaturesTestHelpers.h"
#include "platform/testing/URLTestHelpers.h"
#include "platform/weborigin/KURL.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {
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 kSVGFeaturesHistogramName[] = "Blink.UseCounter.SVGImage.Features";
const char kSVGCSSHistogramName[] = "Blink.UseCounter.SVGImage.CSSProperties";
const char kSVGAnimatedCSSHistogramName[] =
    "Blink.UseCounter.SVGImage.AnimatedCSSProperties";

const char* kHistogramList[] = {
    kFeaturesHistogramName,      kCSSHistogramName,
    kAnimatedCSSHistogramName,   kExtensionFeaturesHistogramName,
    kSVGCSSHistogramName,        kSVGCSSHistogramName,
    kSVGAnimatedCSSHistogramName};

// 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 static_cast<int>(blink::mojom::WebFeature::kPageVisits);
  // For CSS histograms, the page visits bucket should be 1.
  return 1;
}

}  // namespace

namespace blink {
using WebFeature = mojom::WebFeature;

class UseCounterTest : public ::testing::Test {
 public:
  UseCounterTest() : dummy_(DummyPageHolder::Create()) {}

 protected:
  LocalFrame* GetFrame() { return &dummy_->GetFrame(); }
  void SetIsViewSource() { dummy_->GetDocument().SetIsViewSource(true); }
  void SetURL(const KURL& url) { dummy_->GetDocument().SetURL(url); }
  Document& GetDocument() { return dummy_->GetDocument(); }

  template <typename T>
  void HistogramBasicTest(const std::string& histogram,
                          T item,
                          T second_item,
                          std::function<bool(T)> counted,
                          std::function<void(T)> count,
                          std::function<int(T)> histogram_map,
                          std::function<void(LocalFrame*)> did_commit_load,
                          const std::string& url);
  std::unique_ptr<DummyPageHolder> dummy_;
  HistogramTester histogram_tester_;
};

template <typename T>
void UseCounterTest::HistogramBasicTest(
    const std::string& histogram,
    T item,
    T second_item,
    std::function<bool(T)> counted,
    std::function<void(T)> count,
    std::function<int(T)> histogram_map,
    std::function<void(LocalFrame*)> did_commit_load,
    const std::string& url) {
  int page_visits_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);
  // Test that repeated measurements have no effect
  count(item);
  histogram_tester_.ExpectUniqueSample(histogram, histogram_map(item), 1);

  // Test recording a different sample
  EXPECT_FALSE(counted(second_item));
  count(second_item);
  EXPECT_TRUE(counted(second_item));
  histogram_tester_.ExpectBucketCount(histogram, histogram_map(item), 1);
  histogram_tester_.ExpectBucketCount(histogram, histogram_map(second_item), 1);
  histogram_tester_.ExpectTotalCount(histogram, 2);

  // After a page load, the histograms will be updated, even when the URL
  // scheme is internal
  SetURL(URLTestHelpers::ToKURL(url));
  did_commit_load(GetFrame());
  histogram_tester_.ExpectBucketCount(histogram, histogram_map(item), 1);
  histogram_tester_.ExpectBucketCount(histogram, histogram_map(second_item), 1);
  histogram_tester_.ExpectBucketCount(histogram, page_visits_bucket, 1);
  histogram_tester_.ExpectTotalCount(histogram, 3);

  // Now a repeat measurement should get recorded again, exactly once
  EXPECT_FALSE(counted(item));
  count(item);
  count(item);
  EXPECT_TRUE(counted(item));
  histogram_tester_.ExpectBucketCount(histogram, histogram_map(item), 2);
  histogram_tester_.ExpectTotalCount(histogram, 4);

  // For all histograms, no other histograms besides |histogram| should
  // be affected.
  for (const std::string& unaffected_histogram : kHistogramList) {
    if (unaffected_histogram == histogram)
      continue;
    // CSS histograms are never created in didCommitLoad when the context is
    // extension.
    if (histogram == kExtensionFeaturesHistogramName &&
        unaffected_histogram.find("CSS") != std::string::npos)
      continue;

    // The expected total count for "Features" of unaffected histograms should
    // be either:
    //    a. pageVisits, for "CSSFeatures"; or
    //    b. 0 (pageVisits is 0), for others, including "SVGImage.CSSFeatures"
    //      since no SVG images are loaded at all.
    histogram_tester_.ExpectTotalCount(
        unaffected_histogram,
        0 + histogram_tester_.GetBucketCount(
                unaffected_histogram,
                GetPageVisitsBucketforHistogram(unaffected_histogram)));
  }
}

TEST_F(UseCounterTest, RecordingFeatures) {
  UseCounter use_counter;
  HistogramBasicTest<WebFeature>(
      kFeaturesHistogramName, WebFeature::kFetch, WebFeature::kFetchBodyStream,
      [&](WebFeature feature) -> bool {
        return use_counter.HasRecordedMeasurement(feature);
      },
      [&](WebFeature feature) {
        use_counter.RecordMeasurement(feature, *GetFrame());
      },
      [](WebFeature feature) -> int { return static_cast<int>(feature); },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kHttpsUrl);
}

TEST_F(UseCounterTest, RecordingCSSProperties) {
  UseCounter use_counter;
  HistogramBasicTest<CSSPropertyID>(
      kCSSHistogramName, CSSPropertyFont, CSSPropertyZoom,
      [&](CSSPropertyID property) -> bool {
        return use_counter.IsCounted(property);
      },
      [&](CSSPropertyID property) {
        use_counter.Count(kHTMLStandardMode, property);
      },
      [](CSSPropertyID property) -> int {
        return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
      },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kHttpsUrl);
}

TEST_F(UseCounterTest, RecordingAnimatedCSSProperties) {
  UseCounter use_counter;
  HistogramBasicTest<CSSPropertyID>(
      kAnimatedCSSHistogramName, CSSPropertyOpacity, CSSPropertyVariable,
      [&](CSSPropertyID property) -> bool {
        return use_counter.IsCountedAnimatedCSS(property);
      },
      [&](CSSPropertyID property) { use_counter.CountAnimatedCSS(property); },
      [](CSSPropertyID property) -> int {
        return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
      },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kHttpsUrl);
}

TEST_F(UseCounterTest, RecordingExtensions) {
  UseCounter use_counter(UseCounter::kExtensionContext);
  HistogramBasicTest<WebFeature>(
      kExtensionFeaturesHistogramName, WebFeature::kFetch,
      WebFeature::kFetchBodyStream,
      [&](WebFeature feature) -> bool {
        return use_counter.HasRecordedMeasurement(feature);
      },
      [&](WebFeature feature) {
        use_counter.RecordMeasurement(feature, *GetFrame());
      },
      [](WebFeature feature) -> int { return static_cast<int>(feature); },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); },
      kExtensionUrl);
}

TEST_F(UseCounterTest, SVGImageContextFeatures) {
  UseCounter use_counter(UseCounter::kSVGImageContext);
  HistogramBasicTest<WebFeature>(
      kSVGFeaturesHistogramName, WebFeature::kSVGSMILAdditiveAnimation,
      WebFeature::kSVGSMILAnimationElementTiming,
      [&](WebFeature feature) -> bool {
        return use_counter.HasRecordedMeasurement(feature);
      },
      [&](WebFeature feature) {
        use_counter.RecordMeasurement(feature, *GetFrame());
      },
      [](WebFeature feature) -> int { return static_cast<int>(feature); },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kSvgUrl);
}

TEST_F(UseCounterTest, SVGImageContextCSSProperties) {
  UseCounter use_counter(UseCounter::kSVGImageContext);
  HistogramBasicTest<CSSPropertyID>(
      kSVGCSSHistogramName, CSSPropertyFont, CSSPropertyZoom,
      [&](CSSPropertyID property) -> bool {
        return use_counter.IsCounted(property);
      },
      [&](CSSPropertyID property) {
        use_counter.Count(kHTMLStandardMode, property);
      },
      [](CSSPropertyID property) -> int {
        return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
      },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kSvgUrl);
}

TEST_F(UseCounterTest, SVGImageContextAnimatedCSSProperties) {
  UseCounter use_counter(UseCounter::kSVGImageContext);
  HistogramBasicTest<CSSPropertyID>(
      kSVGAnimatedCSSHistogramName, CSSPropertyOpacity, CSSPropertyVariable,
      [&](CSSPropertyID property) -> bool {
        return use_counter.IsCountedAnimatedCSS(property);
      },
      [&](CSSPropertyID property) { use_counter.CountAnimatedCSS(property); },
      [](CSSPropertyID property) -> int {
        return UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property);
      },
      [&](LocalFrame* frame) { use_counter.DidCommitLoad(frame); }, kSvgUrl);
}

TEST_F(UseCounterTest, CSSSelectorPseudoAnyLink) {
  UseCounter use_counter;
  WebFeature feature = WebFeature::kCSSSelectorPseudoAnyLink;
  EXPECT_FALSE(use_counter.IsCounted(GetDocument(), feature));
  use_counter.Count(GetDocument(), feature);
  EXPECT_TRUE(use_counter.IsCounted(GetDocument(), feature));
}

TEST_F(UseCounterTest, CSSSelectorPseudoWebkitAnyLink) {
  UseCounter use_counter;
  WebFeature feature = WebFeature::kCSSSelectorPseudoWebkitAnyLink;
  EXPECT_FALSE(use_counter.IsCounted(GetDocument(), feature));
  use_counter.Count(GetDocument(), feature);
  EXPECT_TRUE(use_counter.IsCounted(GetDocument(), feature));
}

TEST_F(UseCounterTest, CSSTypedOMStylePropertyMap) {
  UseCounter use_counter;
  WebFeature feature = WebFeature::kCSSTypedOMStylePropertyMap;
  EXPECT_FALSE(use_counter.IsCounted(GetDocument(), feature));
  use_counter.Count(GetDocument(), feature);
  EXPECT_TRUE(use_counter.IsCounted(GetDocument(), feature));
}

TEST_F(UseCounterTest, InspectorDisablesMeasurement) {
  UseCounter use_counter;

  // The specific feature we use here isn't important.
  WebFeature feature = WebFeature::kSVGSMILElementInDocument;
  CSSPropertyID property = CSSPropertyFontWeight;
  CSSParserMode parser_mode = kHTMLStandardMode;

  EXPECT_FALSE(use_counter.HasRecordedMeasurement(feature));

  use_counter.MuteForInspector();
  use_counter.RecordMeasurement(feature, *GetFrame());
  EXPECT_FALSE(use_counter.HasRecordedMeasurement(feature));
  use_counter.Count(parser_mode, property);
  EXPECT_FALSE(use_counter.IsCounted(property));
  histogram_tester_.ExpectTotalCount(kFeaturesHistogramName, 0);
  histogram_tester_.ExpectTotalCount(kCSSHistogramName, 0);

  use_counter.MuteForInspector();
  use_counter.RecordMeasurement(feature, *GetFrame());
  EXPECT_FALSE(use_counter.HasRecordedMeasurement(feature));
  use_counter.Count(parser_mode, property);
  EXPECT_FALSE(use_counter.IsCounted(property));
  histogram_tester_.ExpectTotalCount(kFeaturesHistogramName, 0);
  histogram_tester_.ExpectTotalCount(kCSSHistogramName, 0);

  use_counter.UnmuteForInspector();
  use_counter.RecordMeasurement(feature, *GetFrame());
  EXPECT_FALSE(use_counter.HasRecordedMeasurement(feature));
  use_counter.Count(parser_mode, property);
  EXPECT_FALSE(use_counter.IsCounted(property));
  histogram_tester_.ExpectTotalCount(kFeaturesHistogramName, 0);
  histogram_tester_.ExpectTotalCount(kCSSHistogramName, 0);

  use_counter.UnmuteForInspector();
  use_counter.RecordMeasurement(feature, *GetFrame());
  EXPECT_TRUE(use_counter.HasRecordedMeasurement(feature));
  use_counter.Count(parser_mode, property);
  EXPECT_TRUE(use_counter.IsCounted(property));
  histogram_tester_.ExpectUniqueSample(kFeaturesHistogramName,
                                       static_cast<int>(feature), 1);
  histogram_tester_.ExpectUniqueSample(
      kCSSHistogramName,
      UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property), 1);
}

TEST_F(UseCounterTest, DropMeasurementOnViewSourcePages) {
  UseCounter use_counter;
  SetIsViewSource();
  SetURL(URLTestHelpers::ToKURL(kHttpsUrl));
  use_counter.DidCommitLoad(GetFrame());

  WebFeature feature = WebFeature::kFetch;
  EXPECT_FALSE(use_counter.HasRecordedMeasurement(feature));
  histogram_tester_.ExpectTotalCount(kFeaturesHistogramName, 0);
  use_counter.RecordMeasurement(feature, *GetFrame());
  // The feature will be marked as seen.
  EXPECT_TRUE(use_counter.HasRecordedMeasurement(feature));
  // But the feature is not recorded to UMA.
  histogram_tester_.ExpectTotalCount(kFeaturesHistogramName, 0);
}

void ExpectHistograms(const HistogramTester& histogram_tester,
                      int visits_count,
                      WebFeature feature,
                      int feature_count,
                      CSSPropertyID property,
                      int property_count) {
  histogram_tester.ExpectBucketCount(kFeaturesHistogramName,
                                     static_cast<int>(WebFeature::kPageVisits),
                                     visits_count);
  histogram_tester.ExpectBucketCount(kFeaturesHistogramName,
                                     static_cast<int>(feature), feature_count);
  histogram_tester.ExpectTotalCount(kFeaturesHistogramName,
                                    visits_count + feature_count);
  histogram_tester.ExpectBucketCount(kCSSHistogramName, 1, visits_count);
  histogram_tester.ExpectBucketCount(
      kCSSHistogramName,
      UseCounter::MapCSSPropertyIdToCSSSampleIdForHistogram(property),
      property_count);
  histogram_tester.ExpectTotalCount(kCSSHistogramName,
                                    visits_count + property_count);
}

TEST_F(UseCounterTest, MutedDocuments) {
  UseCounter use_counter;
  // Counters triggered before any load are always reported.
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 0, WebFeature::kFetch, 1,
                   CSSPropertyFontWeight, 1);

  // Loading an internal page doesn't bump PageVisits and metrics not reported.
  SetURL(URLTestHelpers::ToKURL(kInternalUrl));
  use_counter.DidCommitLoad(GetFrame());
  EXPECT_FALSE(use_counter.HasRecordedMeasurement(WebFeature::kFetch));
  EXPECT_FALSE(use_counter.IsCounted(CSSPropertyFontWeight));
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 0, WebFeature::kFetch, 1,
                   CSSPropertyFontWeight, 1);

  // But the fact that the features were seen is still known.
  EXPECT_TRUE(use_counter.HasRecordedMeasurement(WebFeature::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(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 0, WebFeature::kFetch, 1,
                   CSSPropertyFontWeight, 1);

  // If we now load a real web page, metrics are reported again.
  SetURL(URLTestHelpers::ToKURL("http://foo.com/"));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 1, WebFeature::kFetch, 2,
                   CSSPropertyFontWeight, 2);

  // HTTPs URLs are the same.
  SetURL(URLTestHelpers::ToKURL(kHttpsUrl));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);

  // Extensions aren't counted.
  SetURL(URLTestHelpers::ToKURL(kExtensionUrl));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);

  // Nor is devtools
  SetURL(URLTestHelpers::ToKURL("chrome-devtools://1238ba908adf/"));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);

  // Nor are data URLs
  SetURL(URLTestHelpers::ToKURL("data:text/plain,thisisaurl"));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);

  // Nor are empty URLs (a main frame with no Document)
  SetURL(NullURL());
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);

  // Or file URLs
  SetURL(URLTestHelpers::ToKURL("file:///c/autoexec.bat"));
  use_counter.DidCommitLoad(GetFrame());
  use_counter.RecordMeasurement(WebFeature::kFetch, *GetFrame());
  use_counter.Count(kHTMLStandardMode, CSSPropertyFontWeight);
  ExpectHistograms(histogram_tester_, 2, WebFeature::kFetch, 3,
                   CSSPropertyFontWeight, 3);
}

class DeprecationTest : public ::testing::Test {
 public:
  DeprecationTest()
      : dummy_(DummyPageHolder::Create()),
        deprecation_(dummy_->GetPage().GetDeprecation()),
        use_counter_(dummy_->GetPage().GetUseCounter()) {}

 protected:
  LocalFrame* GetFrame() { return &dummy_->GetFrame(); }

  std::unique_ptr<DummyPageHolder> dummy_;
  Deprecation& deprecation_;
  UseCounter& use_counter_;
};

TEST_F(DeprecationTest, InspectorDisablesDeprecation) {
  // The specific feature we use here isn't important.
  WebFeature feature = WebFeature::kCSSDeepCombinator;
  CSSPropertyID property = CSSPropertyFontWeight;

  EXPECT_FALSE(deprecation_.IsSuppressed(property));

  deprecation_.MuteForInspector();
  Deprecation::WarnOnDeprecatedProperties(GetFrame(), property);
  EXPECT_FALSE(deprecation_.IsSuppressed(property));
  Deprecation::CountDeprecation(GetFrame(), feature);
  EXPECT_FALSE(use_counter_.HasRecordedMeasurement(feature));

  deprecation_.MuteForInspector();
  Deprecation::WarnOnDeprecatedProperties(GetFrame(), property);
  EXPECT_FALSE(deprecation_.IsSuppressed(property));
  Deprecation::CountDeprecation(GetFrame(), feature);
  EXPECT_FALSE(use_counter_.HasRecordedMeasurement(feature));

  deprecation_.UnmuteForInspector();
  Deprecation::WarnOnDeprecatedProperties(GetFrame(), property);
  EXPECT_FALSE(deprecation_.IsSuppressed(property));
  Deprecation::CountDeprecation(GetFrame(), feature);
  EXPECT_FALSE(use_counter_.HasRecordedMeasurement(feature));

  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));
}

class FeaturePolicyDisabledDeprecationTest
    : public ::testing::Test,
      private ScopedFeaturePolicyForTest {
 public:
  FeaturePolicyDisabledDeprecationTest() : ScopedFeaturePolicyForTest(false) {
    dummy_ = DummyPageHolder::Create();
  }

 protected:
  Document& GetDocument() { return dummy_->GetDocument(); }
  UseCounter& GetUseCounter() { return dummy_->GetPage().GetUseCounter(); }

  std::unique_ptr<DummyPageHolder> dummy_;
};

TEST_F(FeaturePolicyDisabledDeprecationTest,
       TestCountDeprecationFeaturePolicy) {
  // The specific feature we use here isn't important, but we need the
  // corresponding FP feature as well.
  FeaturePolicyFeature policy_feature = FeaturePolicyFeature::kGeolocation;
  WebFeature feature =
      WebFeature::kGeolocationDisallowedByFeaturePolicyInCrossOriginIframe;

  // Verify that there is, in fact, no policy attacted to the document
  ASSERT_EQ(GetDocument().GetFeaturePolicy(), nullptr);
  // Trigger the deprecation counter as if the feature was used.
  Deprecation::CountDeprecationFeaturePolicy(GetDocument(), policy_feature);
  // Verify that no usage was recorded.
  EXPECT_FALSE(GetUseCounter().HasRecordedMeasurement(feature));
}

}  // namespace blink