OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chrome/browser/policy/configuration_policy_handler.h" | |
6 | |
7 #include <algorithm> | |
8 | |
9 #include "base/callback.h" | |
10 #include "base/files/file_path.h" | |
11 #include "base/logging.h" | |
12 #include "base/prefs/pref_value_map.h" | |
13 #include "base/strings/string16.h" | |
14 #include "base/strings/string_number_conversions.h" | |
15 #include "base/strings/string_util.h" | |
16 #include "chrome/browser/policy/configuration_policy_pref_store.h" | |
17 #include "components/policy/core/browser/policy_error_map.h" | |
18 #include "components/policy/core/common/policy_map.h" | |
19 #include "grit/component_strings.h" | |
20 #include "url/gurl.h" | |
21 | |
22 namespace policy { | |
23 | |
24 // ConfigurationPolicyHandler implementation ----------------------------------- | |
25 | |
26 // static | |
27 std::string ConfigurationPolicyHandler::ValueTypeToString(Value::Type type) { | |
28 static const char* strings[] = { | |
29 "null", | |
30 "boolean", | |
31 "integer", | |
32 "double", | |
33 "string", | |
34 "binary", | |
35 "dictionary", | |
36 "list" | |
37 }; | |
38 CHECK(static_cast<size_t>(type) < arraysize(strings)); | |
39 return std::string(strings[type]); | |
40 } | |
41 | |
42 ConfigurationPolicyHandler::ConfigurationPolicyHandler() { | |
43 } | |
44 | |
45 ConfigurationPolicyHandler::~ConfigurationPolicyHandler() { | |
46 } | |
47 | |
48 void ConfigurationPolicyHandler::PrepareForDisplaying( | |
49 PolicyMap* policies) const {} | |
50 | |
51 | |
52 // TypeCheckingPolicyHandler implementation ------------------------------------ | |
53 | |
54 TypeCheckingPolicyHandler::TypeCheckingPolicyHandler( | |
55 const char* policy_name, | |
56 Value::Type value_type) | |
57 : policy_name_(policy_name), | |
58 value_type_(value_type) { | |
59 } | |
60 | |
61 TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() { | |
62 } | |
63 | |
64 const char* TypeCheckingPolicyHandler::policy_name() const { | |
65 return policy_name_; | |
66 } | |
67 | |
68 bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap& policies, | |
69 PolicyErrorMap* errors) { | |
70 const Value* value = NULL; | |
71 return CheckAndGetValue(policies, errors, &value); | |
72 } | |
73 | |
74 bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap& policies, | |
75 PolicyErrorMap* errors, | |
76 const Value** value) { | |
77 *value = policies.GetValue(policy_name_); | |
78 if (*value && !(*value)->IsType(value_type_)) { | |
79 errors->AddError(policy_name_, | |
80 IDS_POLICY_TYPE_ERROR, | |
81 ValueTypeToString(value_type_)); | |
82 return false; | |
83 } | |
84 return true; | |
85 } | |
86 | |
87 | |
88 // IntRangePolicyHandlerBase implementation ------------------------------------ | |
89 | |
90 IntRangePolicyHandlerBase::IntRangePolicyHandlerBase( | |
91 const char* policy_name, | |
92 int min, | |
93 int max, | |
94 bool clamp) | |
95 : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_INTEGER), | |
96 min_(min), | |
97 max_(max), | |
98 clamp_(clamp) { | |
99 } | |
100 | |
101 bool IntRangePolicyHandlerBase::CheckPolicySettings(const PolicyMap& policies, | |
102 PolicyErrorMap* errors) { | |
103 const base::Value* value; | |
104 return CheckAndGetValue(policies, errors, &value) && | |
105 EnsureInRange(value, NULL, errors); | |
106 } | |
107 | |
108 IntRangePolicyHandlerBase::~IntRangePolicyHandlerBase() { | |
109 } | |
110 | |
111 bool IntRangePolicyHandlerBase::EnsureInRange(const base::Value* input, | |
112 int* output, | |
113 PolicyErrorMap* errors) { | |
114 if (!input) | |
115 return true; | |
116 | |
117 int value; | |
118 if (!input->GetAsInteger(&value)) { | |
119 NOTREACHED(); | |
120 return false; | |
121 } | |
122 | |
123 if (value < min_ || value > max_) { | |
124 if (errors) { | |
125 errors->AddError(policy_name(), | |
126 IDS_POLICY_OUT_OF_RANGE_ERROR, | |
127 base::IntToString(value)); | |
128 } | |
129 | |
130 if (!clamp_) | |
131 return false; | |
132 | |
133 value = std::min(std::max(value, min_), max_); | |
134 } | |
135 | |
136 if (output) | |
137 *output = value; | |
138 return true; | |
139 } | |
140 | |
141 | |
142 // StringToIntEnumListPolicyHandler implementation ----------------------------- | |
143 | |
144 StringToIntEnumListPolicyHandler::StringToIntEnumListPolicyHandler( | |
145 const char* policy_name, | |
146 const char* pref_path, | |
147 const MappingEntry* mapping_begin, | |
148 const MappingEntry* mapping_end) | |
149 : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST), | |
150 pref_path_(pref_path), | |
151 mapping_begin_(mapping_begin), | |
152 mapping_end_(mapping_end) {} | |
153 | |
154 bool StringToIntEnumListPolicyHandler::CheckPolicySettings( | |
155 const PolicyMap& policies, | |
156 PolicyErrorMap* errors) { | |
157 const base::Value* value; | |
158 return CheckAndGetValue(policies, errors, &value) && | |
159 Convert(value, NULL, errors); | |
160 } | |
161 | |
162 void StringToIntEnumListPolicyHandler::ApplyPolicySettings( | |
163 const PolicyMap& policies, | |
164 PrefValueMap* prefs) { | |
165 if (!pref_path_) | |
166 return; | |
167 const base::Value* value = policies.GetValue(policy_name()); | |
168 scoped_ptr<base::ListValue> list(new base::ListValue()); | |
169 if (value && Convert(value, list.get(), NULL)) | |
170 prefs->SetValue(pref_path_, list.release()); | |
171 } | |
172 | |
173 bool StringToIntEnumListPolicyHandler::Convert(const base::Value* input, | |
174 base::ListValue* output, | |
175 PolicyErrorMap* errors) { | |
176 if (!input) | |
177 return true; | |
178 | |
179 const base::ListValue* list_value = NULL; | |
180 if (!input->GetAsList(&list_value)) { | |
181 NOTREACHED(); | |
182 return false; | |
183 } | |
184 | |
185 for (base::ListValue::const_iterator entry(list_value->begin()); | |
186 entry != list_value->end(); ++entry) { | |
187 std::string entry_value; | |
188 if (!(*entry)->GetAsString(&entry_value)) { | |
189 if (errors) { | |
190 errors->AddError(policy_name(), | |
191 entry - list_value->begin(), | |
192 IDS_POLICY_TYPE_ERROR, | |
193 ValueTypeToString(base::Value::TYPE_STRING)); | |
194 } | |
195 continue; | |
196 } | |
197 bool found = false; | |
198 for (const MappingEntry* mapping_entry(mapping_begin_); | |
199 mapping_entry != mapping_end_; ++mapping_entry) { | |
200 if (mapping_entry->enum_value == entry_value) { | |
201 found = true; | |
202 if (output) | |
203 output->AppendInteger(mapping_entry->int_value); | |
204 break; | |
205 } | |
206 } | |
207 if (!found) { | |
208 if (errors) { | |
209 errors->AddError(policy_name(), | |
210 entry - list_value->begin(), | |
211 IDS_POLICY_OUT_OF_RANGE_ERROR); | |
212 } | |
213 } | |
214 } | |
215 | |
216 return true; | |
217 } | |
218 | |
219 | |
220 // IntRangePolicyHandler implementation ---------------------------------------- | |
221 | |
222 IntRangePolicyHandler::IntRangePolicyHandler(const char* policy_name, | |
223 const char* pref_path, | |
224 int min, | |
225 int max, | |
226 bool clamp) | |
227 : IntRangePolicyHandlerBase(policy_name, min, max, clamp), | |
228 pref_path_(pref_path) { | |
229 } | |
230 | |
231 IntRangePolicyHandler::~IntRangePolicyHandler() { | |
232 } | |
233 | |
234 void IntRangePolicyHandler::ApplyPolicySettings(const PolicyMap& policies, | |
235 PrefValueMap* prefs) { | |
236 if (!pref_path_) | |
237 return; | |
238 const base::Value* value = policies.GetValue(policy_name()); | |
239 int value_in_range; | |
240 if (value && EnsureInRange(value, &value_in_range, NULL)) { | |
241 prefs->SetValue(pref_path_, | |
242 base::Value::CreateIntegerValue(value_in_range)); | |
243 } | |
244 } | |
245 | |
246 | |
247 // IntPercentageToDoublePolicyHandler implementation --------------------------- | |
248 | |
249 IntPercentageToDoublePolicyHandler::IntPercentageToDoublePolicyHandler( | |
250 const char* policy_name, | |
251 const char* pref_path, | |
252 int min, | |
253 int max, | |
254 bool clamp) | |
255 : IntRangePolicyHandlerBase(policy_name, min, max, clamp), | |
256 pref_path_(pref_path) { | |
257 } | |
258 | |
259 IntPercentageToDoublePolicyHandler::~IntPercentageToDoublePolicyHandler() { | |
260 } | |
261 | |
262 void IntPercentageToDoublePolicyHandler::ApplyPolicySettings( | |
263 const PolicyMap& policies, | |
264 PrefValueMap* prefs) { | |
265 if (!pref_path_) | |
266 return; | |
267 const base::Value* value = policies.GetValue(policy_name()); | |
268 int percentage; | |
269 if (value && EnsureInRange(value, &percentage, NULL)) { | |
270 prefs->SetValue(pref_path_, base::Value::CreateDoubleValue( | |
271 static_cast<double>(percentage) / 100.)); | |
272 } | |
273 } | |
274 | |
275 | |
276 // SimplePolicyHandler implementation ------------------------------------------ | |
277 | |
278 SimplePolicyHandler::SimplePolicyHandler( | |
279 const char* policy_name, | |
280 const char* pref_path, | |
281 Value::Type value_type) | |
282 : TypeCheckingPolicyHandler(policy_name, value_type), | |
283 pref_path_(pref_path) { | |
284 } | |
285 | |
286 SimplePolicyHandler::~SimplePolicyHandler() { | |
287 } | |
288 | |
289 void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap& policies, | |
290 PrefValueMap* prefs) { | |
291 if (!pref_path_) | |
292 return; | |
293 const Value* value = policies.GetValue(policy_name()); | |
294 if (value) | |
295 prefs->SetValue(pref_path_, value->DeepCopy()); | |
296 } | |
297 | |
298 } // namespace policy | |
OLD | NEW |