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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/child_accounts/time_limit_override.h"
#include <utility>
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/values.h"
namespace ash {
namespace usage_time_limit {
namespace {
constexpr char kOverrideAction[] = "action";
constexpr char kOverrideActionCreatedAt[] = "created_at_millis";
constexpr char kOverrideActionDurationMins[] = "duration_mins";
constexpr char kOverrideActionLock[] = "LOCK";
constexpr char kOverrideActionUnlock[] = "UNLOCK";
constexpr char kOverrideActionSpecificData[] = "action_specific_data";
constexpr char kOverrideActionDuration[] = "duration_mins";
// Returns string containing |timestamp| int64_t value in milliseconds. This is
// how timestamp is sent in a policy.
std::string PolicyTimestamp(base::Time timestamp) {
return base::NumberToString(
(timestamp - base::Time::UnixEpoch()).InMilliseconds());
}
} // namespace
// static
constexpr char TimeLimitOverride::kOverridesDictKey[];
// static
std::string TimeLimitOverride::ActionToString(Action action) {
switch (action) {
case Action::kLock:
return kOverrideActionLock;
case Action::kUnlock:
return kOverrideActionUnlock;
}
}
// static
std::optional<TimeLimitOverride> TimeLimitOverride::FromDictionary(
const base::Value::Dict* dict) {
if (!dict) {
DLOG(ERROR) << "Override entry is not a dictionary";
return std::nullopt;
}
const std::string* action_string = dict->FindString(kOverrideAction);
if (!action_string || action_string->empty()) {
DLOG(ERROR) << "Invalid override action.";
return std::nullopt;
}
const std::string* creation_time_string =
dict->FindString(kOverrideActionCreatedAt);
int64_t creation_time_millis;
if (!creation_time_string || creation_time_string->empty() ||
!base::StringToInt64(*creation_time_string, &creation_time_millis)) {
DLOG(ERROR) << "Invalid override creation time.";
return std::nullopt;
}
Action action =
*action_string == kOverrideActionLock ? Action::kLock : Action::kUnlock;
base::Time creation_time =
base::Time::UnixEpoch() + base::Milliseconds(creation_time_millis);
const base::Value::Dict* action_dict =
dict->FindDict(kOverrideActionSpecificData);
const base::Value* duration_value =
action_dict ? action_dict->Find(kOverrideActionDurationMins) : nullptr;
std::optional<base::TimeDelta> duration =
duration_value ? base::Minutes(duration_value->GetInt())
: std::optional<base::TimeDelta>();
return TimeLimitOverride(action, creation_time, duration);
}
// static
std::optional<TimeLimitOverride> TimeLimitOverride::MostRecentFromList(
const base::Value::List* list) {
if (!list) {
DLOG(ERROR) << "Override entries should be a list.";
return std::nullopt;
}
// The most recent override created.
std::optional<TimeLimitOverride> last_override;
for (const base::Value& override_value : *list) {
std::optional<TimeLimitOverride> current_override =
FromDictionary(&override_value.GetDict());
if (!current_override.has_value()) {
DLOG(ERROR) << "Invalid override entry";
continue;
}
if (!last_override.has_value() ||
(current_override->created_at() > last_override->created_at())) {
last_override = std::move(current_override);
}
}
return last_override;
}
TimeLimitOverride::TimeLimitOverride(Action action,
base::Time created_at,
std::optional<base::TimeDelta> duration)
: action_(action), created_at_(created_at), duration_(duration) {}
TimeLimitOverride::~TimeLimitOverride() = default;
TimeLimitOverride::TimeLimitOverride(TimeLimitOverride&&) = default;
TimeLimitOverride& TimeLimitOverride::operator=(TimeLimitOverride&&) = default;
bool TimeLimitOverride::IsLock() const {
return action_ == Action::kLock;
}
base::Value::Dict TimeLimitOverride::ToDictionary() const {
base::Value::Dict dict;
dict.Set(kOverrideAction, base::Value(ActionToString(action_)));
dict.Set(kOverrideActionCreatedAt, base::Value(PolicyTimestamp(created_at_)));
if (duration_.has_value()) {
base::Value::Dict duration_dict;
duration_dict.Set(kOverrideActionDuration,
base::Value(duration_->InMinutes()));
dict.Set(kOverrideActionSpecificData, std::move(duration_dict));
}
return dict;
}
} // namespace usage_time_limit
} // namespace ash
|
