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
|
// Copyright 2017 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/feature_engagement/internal/once_condition_validator.h"
#include <optional>
#include "components/feature_engagement/internal/event_model.h"
#include "components/feature_engagement/internal/time_provider.h"
#include "components/feature_engagement/public/configuration.h"
namespace feature_engagement {
OnceConditionValidator::OnceConditionValidator() = default;
OnceConditionValidator::~OnceConditionValidator() = default;
ConditionValidator::Result OnceConditionValidator::MeetsConditions(
const base::Feature& feature,
const FeatureConfig& config,
const std::vector<GroupConfig>& group_configs,
const EventModelReader& event_model_reader,
const AvailabilityModel& availability_model,
const DisplayLockController& display_lock_controller,
const Configuration* configuration,
const TimeProvider& time_provider) const {
ConditionValidator::Result result(true);
result.event_model_ready_ok = event_model_reader.IsReady();
result.currently_showing_ok =
allows_multiple_features_ || currently_showing_features_.empty();
result.config_ok = config.valid;
result.trigger_ok =
shown_features_.find(feature.name) == shown_features_.end();
result.session_rate_ok =
shown_features_.find(feature.name) == shown_features_.end();
result.snooze_expiration_ok =
!event_model_reader.IsSnoozeDismissed(config.trigger.name) &&
(event_model_reader.GetLastSnoozeTimestamp(config.trigger.name) <
time_provider.Now() - base::Days(config.snooze_params.snooze_interval));
result.priority_notification_ok =
!pending_priority_notification_.has_value() ||
pending_priority_notification_.value() == feature.name;
result.should_show_snooze =
result.snooze_expiration_ok &&
event_model_reader.GetSnoozeCount(
config.trigger.name, config.trigger.window,
time_provider.GetCurrentDay()) < config.snooze_params.max_limit;
return result;
}
void OnceConditionValidator::NotifyIsShowing(
const base::Feature& feature,
const FeatureConfig& config,
const std::vector<std::string>& all_feature_names) {
DCHECK(allows_multiple_features_ || currently_showing_features_.empty());
DCHECK(currently_showing_features_.find(feature.name) ==
currently_showing_features_.end());
DCHECK(shown_features_.find(feature.name) == shown_features_.end());
shown_features_.insert(feature.name);
currently_showing_features_.insert(feature.name);
}
void OnceConditionValidator::NotifyDismissed(const base::Feature& feature) {
DCHECK(currently_showing_features_.find(feature.name) !=
currently_showing_features_.end());
currently_showing_features_.erase(feature.name);
}
void OnceConditionValidator::SetPriorityNotification(
const std::optional<std::string>& feature) {
pending_priority_notification_ = feature;
}
std::optional<std::string>
OnceConditionValidator::GetPendingPriorityNotification() {
return pending_priority_notification_;
}
void OnceConditionValidator::AllowMultipleFeaturesForTesting(
bool allows_multiple_features) {
allows_multiple_features_ = allows_multiple_features;
}
void OnceConditionValidator::ResetSession() {
shown_features_.clear();
}
} // namespace feature_engagement
|
