1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright 2021 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 "third_party/blink/public/common/use_counter/use_counter_feature_tracker.h"
namespace blink {
namespace {
template <size_t N>
bool BitsetContains(const std::bitset<N>& lhs, const std::bitset<N>& rhs) {
return (lhs & rhs) == rhs;
}
} // namespace
using FeatureType = mojom::UseCounterFeatureType;
bool UseCounterFeatureTracker::Test(const UseCounterFeature& feature) const {
switch (feature.type()) {
case FeatureType::kWebFeature:
return web_features_.test(feature.value());
case FeatureType::kCssProperty:
return css_properties_.test(feature.value());
case FeatureType::kAnimatedCssProperty:
return animated_css_properties_.test(feature.value());
case FeatureType::kPermissionsPolicyViolationEnforce:
return violated_permissions_policy_features_.test(feature.value());
case FeatureType::kPermissionsPolicyIframeAttribute:
return iframe_permissions_policy_features_.test(feature.value());
case FeatureType::kPermissionsPolicyHeader:
return header_permissions_policy_features_.test(feature.value());
}
}
bool UseCounterFeatureTracker::TestAndSet(const UseCounterFeature& feature) {
bool has_record = Test(feature);
Set(feature, true);
return has_record;
}
std::vector<UseCounterFeature> UseCounterFeatureTracker::GetRecordedFeatures()
const {
std::vector<UseCounterFeature> ret;
for (uint32_t i = 0; i < web_features_.size(); i++) {
if (web_features_.test(i))
ret.push_back({FeatureType::kWebFeature, i});
}
for (uint32_t i = 0; i < css_properties_.size(); i++) {
if (css_properties_.test(i))
ret.push_back({FeatureType::kCssProperty, i});
}
for (uint32_t i = 0; i < animated_css_properties_.size(); i++) {
if (animated_css_properties_.test(i))
ret.push_back({FeatureType::kAnimatedCssProperty, i});
}
for (uint32_t i = 0; i < violated_permissions_policy_features_.size(); i++) {
if (violated_permissions_policy_features_.test(i))
ret.push_back({FeatureType::kPermissionsPolicyViolationEnforce, i});
}
for (uint32_t i = 0; i < iframe_permissions_policy_features_.size(); i++) {
if (iframe_permissions_policy_features_.test(i))
ret.push_back({FeatureType::kPermissionsPolicyIframeAttribute, i});
}
for (uint32_t i = 0; i < header_permissions_policy_features_.size(); i++) {
if (header_permissions_policy_features_.test(i))
ret.push_back({FeatureType::kPermissionsPolicyHeader, i});
}
return ret;
}
void UseCounterFeatureTracker::ResetForTesting(
const UseCounterFeature& feature) {
Set(feature, false);
}
bool UseCounterFeatureTracker::ContainsForTesting(
const UseCounterFeatureTracker& other) const {
return BitsetContains(web_features_, other.web_features_) &&
BitsetContains(css_properties_, other.css_properties_) &&
BitsetContains(animated_css_properties_,
other.animated_css_properties_);
}
void UseCounterFeatureTracker::Set(const UseCounterFeature& feature,
bool value) {
switch (feature.type()) {
case FeatureType::kWebFeature:
web_features_[feature.value()] = value;
break;
case FeatureType::kCssProperty:
css_properties_[feature.value()] = value;
break;
case FeatureType::kAnimatedCssProperty:
animated_css_properties_[feature.value()] = value;
break;
case FeatureType::kPermissionsPolicyViolationEnforce:
violated_permissions_policy_features_[feature.value()] = value;
break;
case FeatureType::kPermissionsPolicyIframeAttribute:
iframe_permissions_policy_features_[feature.value()] = value;
break;
case FeatureType::kPermissionsPolicyHeader:
header_permissions_policy_features_[feature.value()] = value;
break;
}
}
} // namespace blink
|
