1 // Copyright 2014 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 "components/search_engines/default_search_policy_handler.h" 6 7 #include "base/prefs/pref_value_map.h" 8 #include "base/stl_util.h" 9 #include "base/strings/string_number_conversions.h" 10 #include "base/strings/string_util.h" 11 #include "components/policy/core/browser/policy_error_map.h" 12 #include "components/policy/core/common/policy_map.h" 13 #include "components/search_engines/default_search_manager.h" 14 #include "components/search_engines/search_engines_pref_names.h" 15 #include "components/search_engines/search_terms_data.h" 16 #include "components/search_engines/template_url.h" 17 #include "grit/components_strings.h" 18 #include "policy/policy_constants.h" 19 20 namespace policy { 21 22 namespace { 23 // Extracts a list from a policy value and adds it to a pref dictionary. 24 void SetListInPref(const PolicyMap& policies, 25 const char* policy_name, 26 const char* key, 27 base::DictionaryValue* dict) { 28 DCHECK(dict); 29 const base::Value* policy_value = policies.GetValue(policy_name); 30 const base::ListValue* policy_list = NULL; 31 if (policy_value) { 32 bool is_list = policy_value->GetAsList(&policy_list); 33 DCHECK(is_list); 34 } 35 dict->Set(key, policy_list ? policy_list->DeepCopy() : new base::ListValue()); 36 } 37 38 // Extracts a string from a policy value and adds it to a pref dictionary. 39 void SetStringInPref(const PolicyMap& policies, 40 const char* policy_name, 41 const char* key, 42 base::DictionaryValue* dict) { 43 DCHECK(dict); 44 const base::Value* policy_value = policies.GetValue(policy_name); 45 std::string str; 46 if (policy_value) { 47 bool is_string = policy_value->GetAsString(&str); 48 DCHECK(is_string); 49 } 50 dict->SetString(key, str); 51 } 52 53 } // namespace 54 55 // List of policy types to preference names, for policies affecting the default 56 // search provider. 57 const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[] = { 58 { key::kDefaultSearchProviderEnabled, 59 prefs::kDefaultSearchProviderEnabled, 60 base::Value::TYPE_BOOLEAN }, 61 { key::kDefaultSearchProviderName, 62 prefs::kDefaultSearchProviderName, 63 base::Value::TYPE_STRING }, 64 { key::kDefaultSearchProviderKeyword, 65 prefs::kDefaultSearchProviderKeyword, 66 base::Value::TYPE_STRING }, 67 { key::kDefaultSearchProviderSearchURL, 68 prefs::kDefaultSearchProviderSearchURL, 69 base::Value::TYPE_STRING }, 70 { key::kDefaultSearchProviderSuggestURL, 71 prefs::kDefaultSearchProviderSuggestURL, 72 base::Value::TYPE_STRING }, 73 { key::kDefaultSearchProviderInstantURL, 74 prefs::kDefaultSearchProviderInstantURL, 75 base::Value::TYPE_STRING }, 76 { key::kDefaultSearchProviderIconURL, 77 prefs::kDefaultSearchProviderIconURL, 78 base::Value::TYPE_STRING }, 79 { key::kDefaultSearchProviderEncodings, 80 prefs::kDefaultSearchProviderEncodings, 81 base::Value::TYPE_LIST }, 82 { key::kDefaultSearchProviderAlternateURLs, 83 prefs::kDefaultSearchProviderAlternateURLs, 84 base::Value::TYPE_LIST }, 85 { key::kDefaultSearchProviderSearchTermsReplacementKey, 86 prefs::kDefaultSearchProviderSearchTermsReplacementKey, 87 base::Value::TYPE_STRING }, 88 { key::kDefaultSearchProviderImageURL, 89 prefs::kDefaultSearchProviderImageURL, 90 base::Value::TYPE_STRING }, 91 { key::kDefaultSearchProviderNewTabURL, 92 prefs::kDefaultSearchProviderNewTabURL, 93 base::Value::TYPE_STRING }, 94 { key::kDefaultSearchProviderSearchURLPostParams, 95 prefs::kDefaultSearchProviderSearchURLPostParams, 96 base::Value::TYPE_STRING }, 97 { key::kDefaultSearchProviderSuggestURLPostParams, 98 prefs::kDefaultSearchProviderSuggestURLPostParams, 99 base::Value::TYPE_STRING }, 100 { key::kDefaultSearchProviderInstantURLPostParams, 101 prefs::kDefaultSearchProviderInstantURLPostParams, 102 base::Value::TYPE_STRING }, 103 { key::kDefaultSearchProviderImageURLPostParams, 104 prefs::kDefaultSearchProviderImageURLPostParams, 105 base::Value::TYPE_STRING }, 106 }; 107 108 // List of policy types to preference names, for policies affecting the default 109 // search provider. 110 const PolicyToPreferenceMapEntry kDefaultSearchPolicyDataMap[] = { 111 {key::kDefaultSearchProviderName, DefaultSearchManager::kShortName, 112 base::Value::TYPE_STRING}, 113 {key::kDefaultSearchProviderKeyword, DefaultSearchManager::kKeyword, 114 base::Value::TYPE_STRING}, 115 {key::kDefaultSearchProviderSearchURL, DefaultSearchManager::kURL, 116 base::Value::TYPE_STRING}, 117 {key::kDefaultSearchProviderSuggestURL, 118 DefaultSearchManager::kSuggestionsURL, base::Value::TYPE_STRING}, 119 {key::kDefaultSearchProviderInstantURL, DefaultSearchManager::kInstantURL, 120 base::Value::TYPE_STRING}, 121 {key::kDefaultSearchProviderIconURL, DefaultSearchManager::kFaviconURL, 122 base::Value::TYPE_STRING}, 123 {key::kDefaultSearchProviderEncodings, 124 DefaultSearchManager::kInputEncodings, base::Value::TYPE_LIST}, 125 {key::kDefaultSearchProviderAlternateURLs, 126 DefaultSearchManager::kAlternateURLs, base::Value::TYPE_LIST}, 127 {key::kDefaultSearchProviderSearchTermsReplacementKey, 128 DefaultSearchManager::kSearchTermsReplacementKey, 129 base::Value::TYPE_STRING}, 130 {key::kDefaultSearchProviderImageURL, DefaultSearchManager::kImageURL, 131 base::Value::TYPE_STRING}, 132 {key::kDefaultSearchProviderNewTabURL, DefaultSearchManager::kNewTabURL, 133 base::Value::TYPE_STRING}, 134 {key::kDefaultSearchProviderSearchURLPostParams, 135 DefaultSearchManager::kSearchURLPostParams, base::Value::TYPE_STRING}, 136 {key::kDefaultSearchProviderSuggestURLPostParams, 137 DefaultSearchManager::kSuggestionsURLPostParams, base::Value::TYPE_STRING}, 138 {key::kDefaultSearchProviderInstantURLPostParams, 139 DefaultSearchManager::kInstantURLPostParams, base::Value::TYPE_STRING}, 140 {key::kDefaultSearchProviderImageURLPostParams, 141 DefaultSearchManager::kImageURLPostParams, base::Value::TYPE_STRING}, 142 }; 143 144 // DefaultSearchEncodingsPolicyHandler implementation -------------------------- 145 146 DefaultSearchEncodingsPolicyHandler::DefaultSearchEncodingsPolicyHandler() 147 : TypeCheckingPolicyHandler(key::kDefaultSearchProviderEncodings, 148 base::Value::TYPE_LIST) {} 149 150 DefaultSearchEncodingsPolicyHandler::~DefaultSearchEncodingsPolicyHandler() { 151 } 152 153 void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings( 154 const PolicyMap& policies, PrefValueMap* prefs) { 155 // The DefaultSearchProviderEncodings policy has type list, but the related 156 // preference has type string. Convert one into the other here, using 157 // ';' as a separator. 158 const base::Value* value = policies.GetValue(policy_name()); 159 const base::ListValue* list; 160 if (!value || !value->GetAsList(&list)) 161 return; 162 163 base::ListValue::const_iterator iter(list->begin()); 164 base::ListValue::const_iterator end(list->end()); 165 std::vector<std::string> string_parts; 166 for (; iter != end; ++iter) { 167 std::string s; 168 if ((*iter)->GetAsString(&s)) { 169 string_parts.push_back(s); 170 } 171 } 172 std::string encodings = JoinString(string_parts, ';'); 173 prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings); 174 } 175 176 177 // DefaultSearchPolicyHandler implementation ----------------------------------- 178 179 DefaultSearchPolicyHandler::DefaultSearchPolicyHandler() { 180 for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) { 181 const char* policy_name = kDefaultSearchPolicyMap[i].policy_name; 182 if (policy_name == key::kDefaultSearchProviderEncodings) { 183 handlers_.push_back(new DefaultSearchEncodingsPolicyHandler()); 184 } else { 185 handlers_.push_back(new SimplePolicyHandler( 186 policy_name, 187 kDefaultSearchPolicyMap[i].preference_path, 188 kDefaultSearchPolicyMap[i].value_type)); 189 } 190 } 191 } 192 193 DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() { 194 STLDeleteElements(&handlers_); 195 } 196 197 bool DefaultSearchPolicyHandler::CheckPolicySettings(const PolicyMap& policies, 198 PolicyErrorMap* errors) { 199 if (!CheckIndividualPolicies(policies, errors)) 200 return false; 201 202 if (DefaultSearchProviderIsDisabled(policies)) { 203 // Add an error for all specified default search policies except 204 // DefaultSearchProviderEnabled. 205 206 for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler = 207 handlers_.begin(); 208 handler != handlers_.end(); ++handler) { 209 const char* policy_name = (*handler)->policy_name(); 210 if (policy_name != key::kDefaultSearchProviderEnabled && 211 HasDefaultSearchPolicy(policies, policy_name)) { 212 errors->AddError(policy_name, IDS_POLICY_DEFAULT_SEARCH_DISABLED); 213 } 214 } 215 return true; 216 } 217 218 const base::Value* url; 219 std::string dummy; 220 if (DefaultSearchURLIsValid(policies, &url, &dummy) || 221 !AnyDefaultSearchPoliciesSpecified(policies)) 222 return true; 223 errors->AddError(key::kDefaultSearchProviderSearchURL, url ? 224 IDS_POLICY_INVALID_SEARCH_URL_ERROR : IDS_POLICY_NOT_SPECIFIED_ERROR); 225 return false; 226 } 227 228 void DefaultSearchPolicyHandler::HandleDictionaryPref(const PolicyMap& policies, 229 PrefValueMap* prefs) { 230 if (DefaultSearchProviderIsDisabled(policies)) { 231 scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue); 232 dict->SetBoolean(DefaultSearchManager::kDisabledByPolicy, true); 233 DefaultSearchManager::AddPrefValueToMap(dict.release(), prefs); 234 return; 235 } 236 237 // The search URL is required. The other entries are optional. Just make 238 // sure that they are all specified via policy, so that the regular prefs 239 // aren't used. 240 const base::Value* dummy; 241 std::string url; 242 if (!DefaultSearchURLIsValid(policies, &dummy, &url)) 243 return; 244 245 scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue); 246 for (size_t i = 0; i < arraysize(kDefaultSearchPolicyDataMap); ++i) { 247 const char* policy_name = kDefaultSearchPolicyDataMap[i].policy_name; 248 switch (kDefaultSearchPolicyDataMap[i].value_type) { 249 case base::Value::TYPE_STRING: 250 SetStringInPref(policies, 251 policy_name, 252 kDefaultSearchPolicyDataMap[i].preference_path, 253 dict.get()); 254 break; 255 case base::Value::TYPE_LIST: 256 SetListInPref(policies, 257 policy_name, 258 kDefaultSearchPolicyDataMap[i].preference_path, 259 dict.get()); 260 break; 261 default: 262 NOTREACHED(); 263 break; 264 } 265 } 266 267 // Set the fields which are not specified by the policy to default values. 268 dict->SetString(DefaultSearchManager::kID, 269 base::Int64ToString(kInvalidTemplateURLID)); 270 dict->SetInteger(DefaultSearchManager::kPrepopulateID, 0); 271 dict->SetString(DefaultSearchManager::kSyncGUID, std::string()); 272 dict->SetString(DefaultSearchManager::kOriginatingURL, std::string()); 273 dict->SetBoolean(DefaultSearchManager::kSafeForAutoReplace, true); 274 dict->SetDouble(DefaultSearchManager::kDateCreated, 275 base::Time::Now().ToInternalValue()); 276 dict->SetDouble(DefaultSearchManager::kLastModified, 277 base::Time::Now().ToInternalValue()); 278 dict->SetInteger(DefaultSearchManager::kUsageCount, 0); 279 dict->SetBoolean(DefaultSearchManager::kCreatedByPolicy, true); 280 281 // For the name and keyword, default to the host if not specified. If 282 // there is no host (as is the case with file URLs of the form: 283 // "file:///c:/..."), use "_" to guarantee that the keyword is non-empty. 284 std::string name, keyword; 285 dict->GetString(DefaultSearchManager::kKeyword, &keyword); 286 dict->GetString(DefaultSearchManager::kShortName, &name); 287 dict->GetString(DefaultSearchManager::kURL, &url); 288 289 std::string host(GURL(url).host()); 290 if (host.empty()) 291 host = "_"; 292 if (name.empty()) 293 dict->SetString(DefaultSearchManager::kShortName, host); 294 if (keyword.empty()) 295 dict->SetString(DefaultSearchManager::kKeyword, host); 296 297 DefaultSearchManager::AddPrefValueToMap(dict.release(), prefs); 298 } 299 300 void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies, 301 PrefValueMap* prefs) { 302 HandleDictionaryPref(policies, prefs); 303 304 if (DefaultSearchProviderIsDisabled(policies)) { 305 prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, false); 306 307 // If default search is disabled, the other fields are ignored. 308 prefs->SetString(prefs::kDefaultSearchProviderName, std::string()); 309 prefs->SetString(prefs::kDefaultSearchProviderSearchURL, std::string()); 310 prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, std::string()); 311 prefs->SetString(prefs::kDefaultSearchProviderIconURL, std::string()); 312 prefs->SetString(prefs::kDefaultSearchProviderEncodings, std::string()); 313 prefs->SetString(prefs::kDefaultSearchProviderKeyword, std::string()); 314 prefs->SetString(prefs::kDefaultSearchProviderInstantURL, std::string()); 315 prefs->SetString(prefs::kDefaultSearchProviderNewTabURL, std::string()); 316 prefs->SetValue(prefs::kDefaultSearchProviderAlternateURLs, 317 new base::ListValue()); 318 prefs->SetString( 319 prefs::kDefaultSearchProviderSearchTermsReplacementKey, std::string()); 320 prefs->SetString(prefs::kDefaultSearchProviderImageURL, std::string()); 321 prefs->SetString( 322 prefs::kDefaultSearchProviderSearchURLPostParams, std::string()); 323 prefs->SetString( 324 prefs::kDefaultSearchProviderSuggestURLPostParams, std::string()); 325 prefs->SetString( 326 prefs::kDefaultSearchProviderInstantURLPostParams, std::string()); 327 prefs->SetString( 328 prefs::kDefaultSearchProviderImageURLPostParams, std::string()); 329 } else { 330 // The search URL is required. The other entries are optional. Just make 331 // sure that they are all specified via policy, so that the regular prefs 332 // aren't used. 333 const base::Value* dummy; 334 std::string url; 335 if (DefaultSearchURLIsValid(policies, &dummy, &url)) { 336 337 for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler = 338 handlers_.begin(); 339 handler != handlers_.end(); ++handler) { 340 (*handler)->ApplyPolicySettings(policies, prefs); 341 } 342 343 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderSuggestURL); 344 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderIconURL); 345 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderEncodings); 346 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderKeyword); 347 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderInstantURL); 348 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderNewTabURL); 349 EnsureListPrefExists(prefs, prefs::kDefaultSearchProviderAlternateURLs); 350 EnsureStringPrefExists( 351 prefs, 352 prefs::kDefaultSearchProviderSearchTermsReplacementKey); 353 EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderImageURL); 354 EnsureStringPrefExists( 355 prefs, 356 prefs::kDefaultSearchProviderSearchURLPostParams); 357 EnsureStringPrefExists( 358 prefs, 359 prefs::kDefaultSearchProviderSuggestURLPostParams); 360 EnsureStringPrefExists( 361 prefs, 362 prefs::kDefaultSearchProviderInstantURLPostParams); 363 EnsureStringPrefExists( 364 prefs, 365 prefs::kDefaultSearchProviderImageURLPostParams); 366 367 // For the name and keyword, default to the host if not specified. If 368 // there is no host (file: URLs? Not sure), use "_" to guarantee that the 369 // keyword is non-empty. 370 std::string name, keyword; 371 std::string host(GURL(url).host()); 372 if (host.empty()) 373 host = "_"; 374 if (!prefs->GetString(prefs::kDefaultSearchProviderName, &name) || 375 name.empty()) { 376 prefs->SetString(prefs::kDefaultSearchProviderName, host); 377 } 378 if (!prefs->GetString(prefs::kDefaultSearchProviderKeyword, &keyword) || 379 keyword.empty()) { 380 prefs->SetString(prefs::kDefaultSearchProviderKeyword, host); 381 } 382 383 // And clear the IDs since these are not specified via policy. 384 prefs->SetString(prefs::kDefaultSearchProviderID, std::string()); 385 prefs->SetString(prefs::kDefaultSearchProviderPrepopulateID, 386 std::string()); 387 } 388 } 389 } 390 391 bool DefaultSearchPolicyHandler::CheckIndividualPolicies( 392 const PolicyMap& policies, 393 PolicyErrorMap* errors) { 394 for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler = 395 handlers_.begin(); 396 handler != handlers_.end(); ++handler) { 397 if (!(*handler)->CheckPolicySettings(policies, errors)) 398 return false; 399 } 400 return true; 401 } 402 403 bool DefaultSearchPolicyHandler::HasDefaultSearchPolicy( 404 const PolicyMap& policies, 405 const char* policy_name) { 406 return policies.Get(policy_name) != NULL; 407 } 408 409 bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified( 410 const PolicyMap& policies) { 411 for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler = 412 handlers_.begin(); 413 handler != handlers_.end(); ++handler) { 414 if (policies.Get((*handler)->policy_name())) 415 return true; 416 } 417 return false; 418 } 419 420 bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled( 421 const PolicyMap& policies) { 422 const base::Value* provider_enabled = 423 policies.GetValue(key::kDefaultSearchProviderEnabled); 424 bool enabled = true; 425 return provider_enabled && provider_enabled->GetAsBoolean(&enabled) && 426 !enabled; 427 } 428 429 bool DefaultSearchPolicyHandler::DefaultSearchURLIsValid( 430 const PolicyMap& policies, 431 const base::Value** url_value, 432 std::string* url_string) { 433 *url_value = policies.GetValue(key::kDefaultSearchProviderSearchURL); 434 if (!*url_value || !(*url_value)->GetAsString(url_string) || 435 url_string->empty()) 436 return false; 437 TemplateURLData data; 438 data.SetURL(*url_string); 439 SearchTermsData search_terms_data; 440 return TemplateURL(data).SupportsReplacement(search_terms_data); 441 } 442 443 void DefaultSearchPolicyHandler::EnsureStringPrefExists( 444 PrefValueMap* prefs, 445 const std::string& path) { 446 std::string value; 447 if (!prefs->GetString(path, &value)) 448 prefs->SetString(path, value); 449 } 450 451 void DefaultSearchPolicyHandler::EnsureListPrefExists( 452 PrefValueMap* prefs, 453 const std::string& path) { 454 base::Value* value; 455 base::ListValue* list_value; 456 if (!prefs->GetValue(path, &value) || !value->GetAsList(&list_value)) 457 prefs->SetValue(path, new base::ListValue()); 458 } 459 460 } // namespace policy 461
