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
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/user_education/common/new_badge/new_badge_controller.h"
#include "base/auto_reset.h"
#include "components/user_education/common/user_education_data.h"
#include "components/user_education/common/user_education_features.h"
#include "components/user_education/common/user_education_storage_service.h"
#include "ui/menus/simple_menu_model.h"
namespace user_education {
// static
bool NewBadgeController::disable_new_badges_ = false;
NewBadgeController::NewBadgeController(
NewBadgeRegistry& registry,
UserEducationStorageService& storage_service,
std::unique_ptr<NewBadgePolicy> policy)
: registry_(registry),
storage_service_(storage_service),
policy_(std::move(policy)) {}
void NewBadgeController::InitData() {
// Ensure that all registered New Badge features that are enabled have their
// `feature_enabled_time` set.
for (const auto& [feature, spec] : registry_->feature_data()) {
if (base::FeatureList::IsEnabled(*feature)) {
auto data = storage_service_->ReadNewBadgeData(*feature);
if (data.feature_enabled_time.is_null()) {
data.feature_enabled_time = base::Time::Now();
storage_service_->SaveNewBadgeData(*feature, data);
}
}
}
}
NewBadgeController::~NewBadgeController() = default;
DisplayNewBadge NewBadgeController::MaybeShowNewBadge(
const base::Feature& feature) {
if (disable_new_badges_) {
return DisplayNewBadge();
}
if (!CheckPrerequisites(feature, /*allow_not_registered=*/false)) {
return DisplayNewBadge();
}
NewBadgeData data = storage_service_->ReadNewBadgeData(feature);
CHECK(!data.feature_enabled_time.is_null())
<< "Feature enabled time for " << feature.name
<< " is null; this value should have been set during initialization.";
// Check the policy.
if (!policy_->ShouldShowNewBadge(data, *storage_service_)) {
return ui::IsNewFeatureAtValue();
}
++data.show_count;
storage_service_->SaveNewBadgeData(feature, data);
policy_->RecordNewBadgeShown(feature, data.show_count);
return DisplayNewBadge(base::PassKey<NewBadgeController>(), true);
}
void NewBadgeController::NotifyFeatureUsed(const base::Feature& feature) {
NotifyFeatureUsedImpl(feature, /*allow_not_registered=*/false);
}
void NewBadgeController::NotifyFeatureUsedIfValid(
const base::Feature& feature) {
NotifyFeatureUsedImpl(feature, /*allow_not_registered=*/true);
}
void NewBadgeController::NotifyFeatureUsedImpl(const base::Feature& feature,
bool allow_not_registered) {
if (!CheckPrerequisites(feature, allow_not_registered)) {
return;
}
NewBadgeData data = storage_service_->ReadNewBadgeData(feature);
// Maybe record histograms.
policy_->RecordFeatureUsed(feature, ++data.used_count);
// Maybe save the updated data.
const int cap = policy_->GetFeatureUsedStorageCap();
if (data.used_count <= cap) {
storage_service_->SaveNewBadgeData(feature, data);
}
}
bool NewBadgeController::CheckPrerequisites(const base::Feature& feature,
bool allow_not_registered) const {
// It's possible the same entry point is being re-used for the new feature as
// for an older version; just ignore cases where the new feature is not
// enabled.
if (!base::FeatureList::IsEnabled(feature)) {
return false;
}
// While the registry is largely present to provide metadata, it's not
// possible to correctly calculate the display window if the feature isn't
// registered. Therefore "New" Badges that are not registered are not allowed.
if (!registry_->GetParamsForFeature(feature)) {
DUMP_WILL_BE_CHECK(allow_not_registered)
<< "Tried to access \"New\" Badge data for feature " << feature.name
<< " but new badge was never registered! See "
"browser_user_education_service.cc for full list of registered "
"badges.";
return false;
}
return true;
}
// static
NewBadgeController::TestLock NewBadgeController::DisableNewBadgesForTesting() {
return std::make_unique<base::AutoReset<bool>>(&disable_new_badges_, true);
}
} // namespace user_education
|
