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
|
// 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 "third_party/blink/public/common/frame/user_activation_state.h"
#include "base/metrics/histogram_functions.h"
#include "third_party/blink/public/mojom/frame/user_activation_notification_type.mojom-shared.h"
using blink::mojom::UserActivationNotificationType;
namespace blink {
namespace {
// Indicates if |notification_type| should be considered restricted. See
// |LastActivationWasRestricted| for details.
bool IsRestricted(UserActivationNotificationType notification_type) {
return notification_type == UserActivationNotificationType::
kExtensionMessagingBothPrivileged ||
notification_type == UserActivationNotificationType::
kExtensionMessagingSenderPrivileged ||
notification_type == UserActivationNotificationType::
kExtensionMessagingReceiverPrivileged ||
notification_type == UserActivationNotificationType::
kExtensionMessagingNeitherPrivileged;
}
} // namespace
UserActivationState::UserActivationState()
: first_notification_type_(UserActivationNotificationType::kNone),
last_notification_type_(UserActivationNotificationType::kNone) {}
void UserActivationState::Activate(
UserActivationNotificationType notification_type) {
has_been_active_ = true;
last_activation_was_restricted_ = IsRestricted(notification_type);
ActivateTransientState();
// Update states for UMA.
DCHECK(notification_type != UserActivationNotificationType::kNone);
if (first_notification_type_ == UserActivationNotificationType::kNone)
first_notification_type_ = notification_type;
last_notification_type_ = notification_type;
if (notification_type == UserActivationNotificationType::kInteraction)
transient_state_expiry_time_for_interaction_ = transient_state_expiry_time_;
}
void UserActivationState::SetHasBeenActive() {
has_been_active_ = true;
}
void UserActivationState::Clear() {
has_been_active_ = false;
last_activation_was_restricted_ = false;
first_notification_type_ = UserActivationNotificationType::kNone;
last_notification_type_ = UserActivationNotificationType::kNone;
DeactivateTransientState();
}
bool UserActivationState::HasBeenActive() const {
if (has_been_active_) {
base::UmaHistogramEnumeration("Event.UserActivation.TriggerForSticky",
first_notification_type_);
return true;
}
return false;
}
bool UserActivationState::IsActive() const {
if (IsActiveInternal()) {
base::UmaHistogramEnumeration("Event.UserActivation.TriggerForTransient",
EffectiveNotificationType());
return true;
}
return false;
}
bool UserActivationState::IsActiveInternal() const {
return base::TimeTicks::Now() <= transient_state_expiry_time_;
}
bool UserActivationState::ConsumeIfActive() {
if (!IsActiveInternal())
return false;
DeactivateTransientState();
return true;
}
bool UserActivationState::LastActivationWasRestricted() const {
return last_activation_was_restricted_;
}
void UserActivationState::RecordPreconsumptionUma() const {
if (!IsActiveInternal())
return;
base::UmaHistogramEnumeration("Event.UserActivation.TriggerForConsuming",
EffectiveNotificationType());
}
void UserActivationState::ActivateTransientState() {
transient_state_expiry_time_ = base::TimeTicks::Now() + kActivationLifespan;
}
void UserActivationState::DeactivateTransientState() {
transient_state_expiry_time_ = base::TimeTicks();
transient_state_expiry_time_for_interaction_ = transient_state_expiry_time_;
}
UserActivationNotificationType UserActivationState::EffectiveNotificationType()
const {
// We treat a synthetic activation within the expiry time of a real
// interaction (of type kInteraction) as a real interaction because any user
// of transient activation state should work within that expiry time even if
// we drop all synthetic activations.
return base::TimeTicks::Now() <= transient_state_expiry_time_for_interaction_
? UserActivationNotificationType::kInteraction
: last_notification_type_;
}
} // namespace blink
|
