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/template_url_prepopulate_data.h" 6 7 #if defined(OS_POSIX) && !defined(OS_MACOSX) 8 #include <locale.h> 9 #endif 10 11 #include "base/logging.h" 12 #include "base/prefs/pref_service.h" 13 #include "base/stl_util.h" 14 #include "base/strings/string16.h" 15 #include "base/strings/string_piece.h" 16 #include "base/strings/string_util.h" 17 #include "base/strings/utf_string_conversions.h" 18 #include "components/google/core/browser/google_util.h" 19 #include "components/pref_registry/pref_registry_syncable.h" 20 #include "components/search_engines/prepopulated_engines.h" 21 #include "components/search_engines/search_engines_pref_names.h" 22 #include "components/search_engines/template_url.h" 23 #include "net/base/registry_controlled_domains/registry_controlled_domain.h" 24 #include "url/gurl.h" 25 26 #if defined(OS_WIN) 27 #undef IN // On Windows, windef.h defines this, which screws up "India" cases. 28 #elif defined(OS_MACOSX) 29 #include "base/mac/scoped_cftyperef.h" 30 #endif 31 32 namespace TemplateURLPrepopulateData { 33 34 35 // Helpers -------------------------------------------------------------------- 36 37 namespace { 38 39 // NOTE: You should probably not change the data in this file without changing 40 // |kCurrentDataVersion| in prepopulated_engines.json. See comments in 41 // GetDataVersion() below! 42 43 // Put the engines within each country in order with most interesting/important 44 // first. The default will be the first engine. 45 46 // Default (for countries with no better engine set) 47 const PrepopulatedEngine* engines_default[] = 48 { &google, &bing, &yahoo, }; 49 50 // United Arab Emirates 51 const PrepopulatedEngine* engines_AE[] = 52 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 53 54 // Albania 55 const PrepopulatedEngine* engines_AL[] = 56 { &google, &yahoo, &bing_en_XA, &bing_ar_XA, }; 57 58 // Argentina 59 const PrepopulatedEngine* engines_AR[] = 60 { &google, &bing_es_AR, &yahoo_ar, }; 61 62 // Austria 63 const PrepopulatedEngine* engines_AT[] = 64 { &google, &bing_de_AT, &yahoo_at, }; 65 66 // Australia 67 const PrepopulatedEngine* engines_AU[] = 68 { &google, &bing_en_AU, &yahoo_au, }; 69 70 // Bosnia and Herzegovina 71 const PrepopulatedEngine* engines_BA[] = 72 { &google, &yahoo, &bing, }; 73 74 // Belgium 75 const PrepopulatedEngine* engines_BE[] = 76 { &google, &bing_nl_BE, &bing_fr_BE, &yahoo, &yahoo_fr, }; 77 78 // Bulgaria 79 const PrepopulatedEngine* engines_BG[] = 80 { &google, &bing, &ask, }; 81 82 // Bahrain 83 const PrepopulatedEngine* engines_BH[] = 84 { &google, &yahoo_maktoob, &bing_en_XA, &bing_ar_XA, }; 85 86 // Burundi 87 const PrepopulatedEngine* engines_BI[] = 88 { &google, &yahoo, &bing, }; 89 90 // Brunei 91 const PrepopulatedEngine* engines_BN[] = 92 { &google, &yahoo_my, &bing, }; 93 94 // Bolivia 95 const PrepopulatedEngine* engines_BO[] = 96 { &google, &bing_es_XL, &yahoo, }; 97 98 // Brazil 99 const PrepopulatedEngine* engines_BR[] = 100 { &google, &ask_br, &bing_pt_BR, &yahoo_br, }; 101 102 // Belarus 103 const PrepopulatedEngine* engines_BY[] = 104 { &google, &yahoo_ru, &bing_ru_RU, }; 105 106 // Belize 107 const PrepopulatedEngine* engines_BZ[] = 108 { &google, &yahoo, &bing, }; 109 110 // Canada 111 const PrepopulatedEngine* engines_CA[] = 112 { &google, &bing_en_CA, &bing_fr_CA, &ask, &yahoo_ca, &yahoo_qc, }; 113 114 // Switzerland 115 const PrepopulatedEngine* engines_CH[] = 116 { &google, &bing_de_CH, &bing_fr_CH, &yahoo_ch, }; 117 118 // Chile 119 const PrepopulatedEngine* engines_CL[] = 120 { &google, &bing_es_CL, &yahoo_cl, }; 121 122 // China 123 const PrepopulatedEngine* engines_CN[] = 124 { &google, &baidu, &sogou, }; 125 126 // Colombia 127 const PrepopulatedEngine* engines_CO[] = 128 { &google, &bing_es_XL, &yahoo_co, }; 129 130 // Costa Rica 131 const PrepopulatedEngine* engines_CR[] = 132 { &google, &yahoo, &bing_es_XL, }; 133 134 // Czech Republic 135 const PrepopulatedEngine* engines_CZ[] = 136 { &google, &seznam, &bing, }; 137 138 // Germany 139 const PrepopulatedEngine* engines_DE[] = 140 { &google, &bing_de_DE, &yahoo_de }; 141 142 // Denmark 143 const PrepopulatedEngine* engines_DK[] = 144 { &google, &bing_da_DK, &yahoo_dk, }; 145 146 // Dominican Republic 147 const PrepopulatedEngine* engines_DO[] = 148 { &google, &yahoo, &bing_es_XL, }; 149 150 // Algeria 151 const PrepopulatedEngine* engines_DZ[] = 152 { &google, &bing_ar_XA, &bing_en_XA, &yahoo_maktoob, }; 153 154 // Ecuador 155 const PrepopulatedEngine* engines_EC[] = 156 { &google, &bing_es_XL, &yahoo, }; 157 158 // Estonia 159 const PrepopulatedEngine* engines_EE[] = 160 { &google, &bing, &yahoo, }; 161 162 // Egypt 163 const PrepopulatedEngine* engines_EG[] = 164 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 165 166 // Spain 167 const PrepopulatedEngine* engines_ES[] = 168 { &google, &bing_es_ES, &yahoo_es, }; 169 170 // Faroe Islands 171 const PrepopulatedEngine* engines_FO[] = 172 { &google, &bing_da_DK, &ask, }; 173 174 // Finland 175 const PrepopulatedEngine* engines_FI[] = 176 { &google, &bing_fi_FI, &yahoo_fi, }; 177 178 // France 179 const PrepopulatedEngine* engines_FR[] = 180 { &google, &bing_fr_FR, &yahoo_fr, }; 181 182 // United Kingdom 183 const PrepopulatedEngine* engines_GB[] = 184 { &google, &bing_en_GB, &yahoo_uk, &ask_uk, }; 185 186 // Greece 187 const PrepopulatedEngine* engines_GR[] = 188 { &google, &bing, &yahoo_gr, }; 189 190 // Guatemala 191 const PrepopulatedEngine* engines_GT[] = 192 { &google, &yahoo, &bing_es_XL, }; 193 194 // Hong Kong 195 const PrepopulatedEngine* engines_HK[] = 196 { &google, &yahoo_hk, &baidu, &bing_zh_HK, }; 197 198 // Honduras 199 const PrepopulatedEngine* engines_HN[] = 200 { &google, &yahoo, &bing_es_XL, }; 201 202 // Croatia 203 const PrepopulatedEngine* engines_HR[] = 204 { &google, &bing, &yahoo, }; 205 206 // Hungary 207 const PrepopulatedEngine* engines_HU[] = 208 { &google, &bing, &yahoo, }; 209 210 // Indonesia 211 const PrepopulatedEngine* engines_ID[] = 212 { &google, &yahoo_id, &bing, }; 213 214 // Ireland 215 const PrepopulatedEngine* engines_IE[] = 216 { &google, &bing_en_IE, &yahoo_uk, }; 217 218 // Israel 219 const PrepopulatedEngine* engines_IL[] = 220 { &google, &yahoo, &bing, }; 221 222 // India 223 const PrepopulatedEngine* engines_IN[] = 224 { &google, &bing_en_IN, &yahoo_in, }; 225 226 // Iraq 227 const PrepopulatedEngine* engines_IQ[] = 228 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 229 230 // Iran 231 const PrepopulatedEngine* engines_IR[] = 232 { &google, &yahoo, &bing, }; 233 234 // Iceland 235 const PrepopulatedEngine* engines_IS[] = 236 { &google, &bing, &yahoo, }; 237 238 // Italy 239 const PrepopulatedEngine* engines_IT[] = 240 { &google, &virgilio, &bing_it_IT, }; 241 242 // Jamaica 243 const PrepopulatedEngine* engines_JM[] = 244 { &google, &yahoo, &bing, }; 245 246 // Jordan 247 const PrepopulatedEngine* engines_JO[] = 248 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 249 250 // Japan 251 const PrepopulatedEngine* engines_JP[] = 252 { &google, &yahoo_jp, &bing_ja_JP, }; 253 254 // Kenya 255 const PrepopulatedEngine* engines_KE[] = 256 { &google, &yahoo, &bing, }; 257 258 // Kuwait 259 const PrepopulatedEngine* engines_KW[] = 260 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 261 262 // South Korea 263 const PrepopulatedEngine* engines_KR[] = 264 { &google, &naver, &daum, }; 265 266 // Kazakhstan 267 const PrepopulatedEngine* engines_KZ[] = 268 { &google, &bing, &yahoo, }; 269 270 // Lebanon 271 const PrepopulatedEngine* engines_LB[] = 272 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 273 274 // Liechtenstein 275 const PrepopulatedEngine* engines_LI[] = 276 { &google, &bing_de_DE, &yahoo_de, }; 277 278 // Lithuania 279 const PrepopulatedEngine* engines_LT[] = 280 { &google, &bing, &yandex_ru, }; 281 282 // Luxembourg 283 const PrepopulatedEngine* engines_LU[] = 284 { &google, &bing_fr_FR, &yahoo_fr, }; 285 286 // Latvia 287 const PrepopulatedEngine* engines_LV[] = 288 { &google, &yandex_ru, &bing, }; 289 290 // Libya 291 const PrepopulatedEngine* engines_LY[] = 292 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 293 294 // Morocco 295 const PrepopulatedEngine* engines_MA[] = 296 { &google, &bing_ar_XA, &bing_en_XA, &yahoo_maktoob, }; 297 298 // Monaco 299 const PrepopulatedEngine* engines_MC[] = 300 { &google, &yahoo_fr, &bing_fr_FR, }; 301 302 // Moldova 303 const PrepopulatedEngine* engines_MD[] = 304 { &google, &bing, &yahoo, }; 305 306 // Montenegro 307 const PrepopulatedEngine* engines_ME[] = 308 { &google, &bing, &yahoo, }; 309 310 // Macedonia 311 const PrepopulatedEngine* engines_MK[] = 312 { &google, &yahoo, &bing, }; 313 314 // Mexico 315 const PrepopulatedEngine* engines_MX[] = 316 { &google, &bing_es_MX, &yahoo_mx, }; 317 318 // Malaysia 319 const PrepopulatedEngine* engines_MY[] = 320 { &google, &yahoo_my, &bing, }; 321 322 // Nicaragua 323 const PrepopulatedEngine* engines_NI[] = 324 { &google, &yahoo, &bing_es_XL, }; 325 326 // Netherlands 327 const PrepopulatedEngine* engines_NL[] = 328 { &google, &yahoo_nl, &vinden, }; 329 330 // Norway 331 const PrepopulatedEngine* engines_NO[] = 332 { &google, &bing_nb_NO, &kvasir, }; 333 334 // New Zealand 335 const PrepopulatedEngine* engines_NZ[] = 336 { &google, &bing_en_NZ, &yahoo_nz, }; 337 338 // Oman 339 const PrepopulatedEngine* engines_OM[] = 340 { &google, &bing_ar_XA, &yahoo_maktoob, &bing_en_XA, }; 341 342 // Panama 343 const PrepopulatedEngine* engines_PA[] = 344 { &google, &yahoo, &bing_es_XL, }; 345 346 // Peru 347 const PrepopulatedEngine* engines_PE[] = 348 { &google, &bing_es_XL, &yahoo_pe, }; 349 350 // Philippines 351 const PrepopulatedEngine* engines_PH[] = 352 { &google, &yahoo_ph, &bing_en_PH, }; 353 354 // Pakistan 355 const PrepopulatedEngine* engines_PK[] = 356 { &google, &yahoo, &bing, }; 357 358 // Puerto Rico 359 const PrepopulatedEngine* engines_PR[] = 360 { &google, &yahoo, &bing_es_XL, }; 361 362 // Poland 363 const PrepopulatedEngine* engines_PL[] = 364 { &google, &onet, &bing_pl_PL, }; 365 366 // Portugal 367 const PrepopulatedEngine* engines_PT[] = 368 { &google, &bing_pt_PT, &yahoo, }; 369 370 // Paraguay 371 const PrepopulatedEngine* engines_PY[] = 372 { &google, &bing_es_XL, &yahoo, }; 373 374 // Qatar 375 const PrepopulatedEngine* engines_QA[] = 376 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 377 378 // Romania 379 const PrepopulatedEngine* engines_RO[] = 380 { &google, &yahoo_ro, &bing, }; 381 382 // Serbia 383 const PrepopulatedEngine* engines_RS[] = 384 { &google, &bing, &yahoo, }; 385 386 // Russia 387 const PrepopulatedEngine* engines_RU[] = 388 { &google, &yandex_ru, &mail_ru, }; 389 390 // Rwanda 391 const PrepopulatedEngine* engines_RW[] = 392 { &google, &bing, &yahoo, }; 393 394 // Saudi Arabia 395 const PrepopulatedEngine* engines_SA[] = 396 { &google, &yahoo_maktoob, &bing_ar_XA, &bing_en_XA, }; 397 398 // Sweden 399 const PrepopulatedEngine* engines_SE[] = 400 { &google, &bing_sv_SE, &yahoo_se, }; 401 402 // Singapore 403 const PrepopulatedEngine* engines_SG[] = 404 { &google, &yahoo_sg, &bing_en_SG, }; 405 406 // Slovenia 407 const PrepopulatedEngine* engines_SI[] = 408 { &google, &najdi, &ask, }; 409 410 // Slovakia 411 const PrepopulatedEngine* engines_SK[] = 412 { &google, &bing, &yahoo, }; 413 414 // El Salvador 415 const PrepopulatedEngine* engines_SV[] = 416 { &google, &yahoo, &bing_es_XL, }; 417 418 // Syria 419 const PrepopulatedEngine* engines_SY[] = 420 { &google, &bing_ar_XA, &bing_en_XA, &yahoo_maktoob, }; 421 422 // Thailand 423 const PrepopulatedEngine* engines_TH[] = 424 { &google, &yahoo_th, &bing, }; 425 426 // Tunisia 427 const PrepopulatedEngine* engines_TN[] = 428 { &google, &bing_ar_XA, &bing_en_XA, &yahoo_maktoob, }; 429 430 // Turkey 431 const PrepopulatedEngine* engines_TR[] = 432 { &google, &bing_tr_TR, &yahoo_tr, &yandex_tr, }; 433 434 // Trinidad and Tobago 435 const PrepopulatedEngine* engines_TT[] = 436 { &google, &bing, &yahoo, }; 437 438 // Taiwan 439 const PrepopulatedEngine* engines_TW[] = 440 { &google, &yahoo_tw, &bing_zh_TW, }; 441 442 // Tanzania 443 const PrepopulatedEngine* engines_TZ[] = 444 { &google, &yahoo, &bing, }; 445 446 // Ukraine 447 const PrepopulatedEngine* engines_UA[] = 448 { &google, &yandex_ua, &bing_ru_RU, }; 449 450 // United States 451 const PrepopulatedEngine* engines_US[] = 452 { &google, &bing_en_US, &yahoo, &aol, &ask, }; 453 454 // Uruguay 455 const PrepopulatedEngine* engines_UY[] = 456 { &google, &bing_es_XL, &yahoo, }; 457 458 // Venezuela 459 const PrepopulatedEngine* engines_VE[] = 460 { &google, &bing_es_XL, &yahoo_ve, }; 461 462 // Vietnam 463 const PrepopulatedEngine* engines_VN[] = 464 { &google, &yahoo_vn, &bing, }; 465 466 // Yemen 467 const PrepopulatedEngine* engines_YE[] = 468 { &google, &bing_ar_XA, &bing_en_XA, &yahoo_maktoob, }; 469 470 // South Africa 471 const PrepopulatedEngine* engines_ZA[] = 472 { &google, &bing, &yahoo, }; 473 474 // Zimbabwe 475 const PrepopulatedEngine* engines_ZW[] = 476 { &google, &bing, &yahoo, &ask, }; 477 478 // A list of all the engines that we know about. 479 const PrepopulatedEngine* kAllEngines[] = { 480 // Prepopulated engines: 481 &aol, &ask, &ask_br, &ask_uk, &baidu, 482 &bing, &bing_ar_XA, &bing_da_DK, &bing_de_AT, &bing_de_CH, 483 &bing_de_DE, &bing_en_AU, &bing_en_CA, &bing_en_GB, &bing_en_IE, 484 &bing_en_IN, &bing_en_NZ, &bing_en_PH, &bing_en_SG, &bing_en_US, 485 &bing_en_XA, &bing_es_AR, &bing_es_CL, &bing_es_ES, &bing_es_MX, 486 &bing_es_XL, &bing_fi_FI, &bing_fr_BE, &bing_fr_CA, &bing_fr_CH, 487 &bing_fr_FR, &bing_it_IT, &bing_ja_JP, &bing_lv_LV, &bing_nb_NO, 488 &bing_nl_BE, &bing_pl_PL, &bing_pt_BR, &bing_pt_PT, &bing_ru_RU, 489 &bing_sv_SE, &bing_tr_TR, &bing_zh_HK, &bing_zh_TW, &daum, 490 &google, &kvasir, &mail_ru, &najdi, &naver, 491 &onet, &seznam, &sogou, &vinden, &virgilio, 492 &yahoo, &yahoo_ar, &yahoo_at, &yahoo_au, &yahoo_br, 493 &yahoo_ca, &yahoo_ch, &yahoo_cl, &yahoo_co, &yahoo_de, 494 &yahoo_dk, &yahoo_es, &yahoo_fi, &yahoo_fr, &yahoo_gr, 495 &yahoo_hk, &yahoo_id, &yahoo_in, &yahoo_jp, &yahoo_maktoob, 496 &yahoo_mx, &yahoo_my, &yahoo_nl, &yahoo_nz, &yahoo_pe, 497 &yahoo_ph, &yahoo_qc, &yahoo_ro, &yahoo_ru, &yahoo_se, 498 &yahoo_sg, &yahoo_th, &yahoo_tr, &yahoo_tw, &yahoo_uk, 499 &yahoo_ve, &yahoo_vn, &yandex_ru, &yandex_tr, &yandex_ua, 500 501 // UMA-only engines: 502 &atlas_cz, &atlas_sk, &avg, &babylon, &conduit, 503 &delfi_lt, &delfi_lv, &delta, &funmoods, &goo, 504 &imesh, &iminent, &in, &incredibar, &libero, 505 &neti, &nigma, &ok, &rambler, &sapo, 506 &search_results, &searchnu, &snapdo, &softonic, &sweetim, 507 &terra_ar, &terra_es, &tut, &walla, &wp, 508 &zoznam, 509 }; 510 511 // Please refer to ISO 3166-1 for information about the two-character country 512 // codes; http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 is useful. In the 513 // following (C++) code, we pack the two letters of the country code into an int 514 // value we call the CountryID. 515 516 const int kCountryIDUnknown = -1; 517 518 inline int CountryCharsToCountryID(char c1, char c2) { 519 return c1 << 8 | c2; 520 } 521 522 int CountryCharsToCountryIDWithUpdate(char c1, char c2) { 523 // SPECIAL CASE: In 2003, Yugoslavia renamed itself to Serbia and Montenegro. 524 // Serbia and Montenegro dissolved their union in June 2006. Yugoslavia was 525 // ISO 'YU' and Serbia and Montenegro were ISO 'CS'. Serbia was subsequently 526 // issued 'RS' and Montenegro 'ME'. Windows XP and Mac OS X Leopard still use 527 // the value 'YU'. If we get a value of 'YU' or 'CS' we will map it to 'RS'. 528 if ((c1 == 'Y' && c2 == 'U') || 529 (c1 == 'C' && c2 == 'S')) { 530 c1 = 'R'; 531 c2 = 'S'; 532 } 533 534 // SPECIAL CASE: Timor-Leste changed from 'TP' to 'TL' in 2002. Windows XP 535 // predates this; we therefore map this value. 536 if (c1 == 'T' && c2 == 'P') 537 c2 = 'L'; 538 539 return CountryCharsToCountryID(c1, c2); 540 } 541 542 #if defined(OS_WIN) 543 544 // For reference, a list of GeoIDs can be found at 545 // http://msdn.microsoft.com/en-us/library/dd374073.aspx . 546 int GeoIDToCountryID(GEOID geo_id) { 547 const int kISOBufferSize = 3; // Two plus one for the terminator. 548 wchar_t isobuf[kISOBufferSize] = { 0 }; 549 int retval = GetGeoInfo(geo_id, GEO_ISO2, isobuf, kISOBufferSize, 0); 550 551 if (retval == kISOBufferSize && 552 !(isobuf[0] == L'X' && isobuf[1] == L'X')) 553 return CountryCharsToCountryIDWithUpdate(static_cast<char>(isobuf[0]), 554 static_cast<char>(isobuf[1])); 555 556 // Various locations have ISO codes that Windows does not return. 557 switch (geo_id) { 558 case 0x144: // Guernsey 559 return CountryCharsToCountryID('G', 'G'); 560 case 0x148: // Jersey 561 return CountryCharsToCountryID('J', 'E'); 562 case 0x3B16: // Isle of Man 563 return CountryCharsToCountryID('I', 'M'); 564 565 // 'UM' (U.S. Minor Outlying Islands) 566 case 0x7F: // Johnston Atoll 567 case 0x102: // Wake Island 568 case 0x131: // Baker Island 569 case 0x146: // Howland Island 570 case 0x147: // Jarvis Island 571 case 0x149: // Kingman Reef 572 case 0x152: // Palmyra Atoll 573 case 0x52FA: // Midway Islands 574 return CountryCharsToCountryID('U', 'M'); 575 576 // 'SH' (Saint Helena) 577 case 0x12F: // Ascension Island 578 case 0x15C: // Tristan da Cunha 579 return CountryCharsToCountryID('S', 'H'); 580 581 // 'IO' (British Indian Ocean Territory) 582 case 0x13A: // Diego Garcia 583 return CountryCharsToCountryID('I', 'O'); 584 585 // Other cases where there is no ISO country code; we assign countries that 586 // can serve as reasonable defaults. 587 case 0x154: // Rota Island 588 case 0x155: // Saipan 589 case 0x15A: // Tinian Island 590 return CountryCharsToCountryID('U', 'S'); 591 case 0x134: // Channel Islands 592 return CountryCharsToCountryID('G', 'B'); 593 case 0x143: // Guantanamo Bay 594 default: 595 return kCountryIDUnknown; 596 } 597 } 598 599 int GetCurrentCountryID() { 600 GEOID geo_id = GetUserGeoID(GEOCLASS_NATION); 601 602 return GeoIDToCountryID(geo_id); 603 } 604 605 #elif defined(OS_MACOSX) 606 607 int GetCurrentCountryID() { 608 base::ScopedCFTypeRef<CFLocaleRef> locale(CFLocaleCopyCurrent()); 609 CFStringRef country = (CFStringRef)CFLocaleGetValue(locale.get(), 610 kCFLocaleCountryCode); 611 if (!country) 612 return kCountryIDUnknown; 613 614 UniChar isobuf[2]; 615 CFRange char_range = CFRangeMake(0, 2); 616 CFStringGetCharacters(country, char_range, isobuf); 617 618 return CountryCharsToCountryIDWithUpdate(static_cast<char>(isobuf[0]), 619 static_cast<char>(isobuf[1])); 620 } 621 622 #elif defined(OS_ANDROID) 623 624 // Initialized by InitCountryCode(). 625 int g_country_code_at_install = kCountryIDUnknown; 626 627 int GetCurrentCountryID() { 628 return g_country_code_at_install; 629 } 630 631 #elif defined(OS_POSIX) 632 633 int GetCurrentCountryID() { 634 const char* locale = setlocale(LC_MESSAGES, NULL); 635 636 if (!locale) 637 return kCountryIDUnknown; 638 639 // The format of a locale name is: 640 // language[_territory][.codeset][@modifier], where territory is an ISO 3166 641 // country code, which is what we want. 642 std::string locale_str(locale); 643 size_t begin = locale_str.find('_'); 644 if (begin == std::string::npos || locale_str.size() - begin < 3) 645 return kCountryIDUnknown; 646 647 ++begin; 648 size_t end = locale_str.find_first_of(".@", begin); 649 if (end == std::string::npos) 650 end = locale_str.size(); 651 652 // The territory part must contain exactly two characters. 653 if (end - begin == 2) { 654 return CountryCharsToCountryIDWithUpdate( 655 base::ToUpperASCII(locale_str[begin]), 656 base::ToUpperASCII(locale_str[begin + 1])); 657 } 658 659 return kCountryIDUnknown; 660 } 661 662 #endif // OS_* 663 664 int GetCountryIDFromPrefs(PrefService* prefs) { 665 if (!prefs) 666 return GetCurrentCountryID(); 667 668 // Cache first run Country ID value in prefs, and use it afterwards. This 669 // ensures that just because the user moves around, we won't automatically 670 // make major changes to their available search providers, which would feel 671 // surprising. 672 if (!prefs->HasPrefPath(prefs::kCountryIDAtInstall)) { 673 prefs->SetInteger(prefs::kCountryIDAtInstall, GetCurrentCountryID()); 674 } 675 return prefs->GetInteger(prefs::kCountryIDAtInstall); 676 } 677 678 void GetPrepopulationSetFromCountryID(PrefService* prefs, 679 const PrepopulatedEngine*** engines, 680 size_t* num_engines) { 681 // NOTE: This function should ALWAYS set its outparams. 682 683 // If you add a new country make sure to update the unit test for coverage. 684 switch (GetCountryIDFromPrefs(prefs)) { 685 686 #define CHAR_A 'A' 687 #define CHAR_B 'B' 688 #define CHAR_C 'C' 689 #define CHAR_D 'D' 690 #define CHAR_E 'E' 691 #define CHAR_F 'F' 692 #define CHAR_G 'G' 693 #define CHAR_H 'H' 694 #define CHAR_I 'I' 695 #define CHAR_J 'J' 696 #define CHAR_K 'K' 697 #define CHAR_L 'L' 698 #define CHAR_M 'M' 699 #define CHAR_N 'N' 700 #define CHAR_O 'O' 701 #define CHAR_P 'P' 702 #define CHAR_Q 'Q' 703 #define CHAR_R 'R' 704 #define CHAR_S 'S' 705 #define CHAR_T 'T' 706 #define CHAR_U 'U' 707 #define CHAR_V 'V' 708 #define CHAR_W 'W' 709 #define CHAR_X 'X' 710 #define CHAR_Y 'Y' 711 #define CHAR_Z 'Z' 712 #define CHAR(ch) CHAR_##ch 713 #define CODE_TO_ID(code1, code2)\ 714 (CHAR(code1) << 8 | CHAR(code2)) 715 716 #define UNHANDLED_COUNTRY(code1, code2)\ 717 case CODE_TO_ID(code1, code2): 718 #define END_UNHANDLED_COUNTRIES(code1, code2)\ 719 *engines = engines_##code1##code2;\ 720 *num_engines = arraysize(engines_##code1##code2);\ 721 return; 722 #define DECLARE_COUNTRY(code1, code2)\ 723 UNHANDLED_COUNTRY(code1, code2)\ 724 END_UNHANDLED_COUNTRIES(code1, code2) 725 726 // Countries with their own, dedicated engine set. 727 DECLARE_COUNTRY(A, E) // United Arab Emirates 728 DECLARE_COUNTRY(A, L) // Albania 729 DECLARE_COUNTRY(A, R) // Argentina 730 DECLARE_COUNTRY(A, T) // Austria 731 DECLARE_COUNTRY(A, U) // Australia 732 DECLARE_COUNTRY(B, A) // Bosnia and Herzegovina 733 DECLARE_COUNTRY(B, E) // Belgium 734 DECLARE_COUNTRY(B, G) // Bulgaria 735 DECLARE_COUNTRY(B, H) // Bahrain 736 DECLARE_COUNTRY(B, I) // Burundi 737 DECLARE_COUNTRY(B, N) // Brunei 738 DECLARE_COUNTRY(B, O) // Bolivia 739 DECLARE_COUNTRY(B, R) // Brazil 740 DECLARE_COUNTRY(B, Y) // Belarus 741 DECLARE_COUNTRY(B, Z) // Belize 742 DECLARE_COUNTRY(C, A) // Canada 743 DECLARE_COUNTRY(C, H) // Switzerland 744 DECLARE_COUNTRY(C, L) // Chile 745 DECLARE_COUNTRY(C, N) // China 746 DECLARE_COUNTRY(C, O) // Colombia 747 DECLARE_COUNTRY(C, R) // Costa Rica 748 DECLARE_COUNTRY(C, Z) // Czech Republic 749 DECLARE_COUNTRY(D, E) // Germany 750 DECLARE_COUNTRY(D, K) // Denmark 751 DECLARE_COUNTRY(D, O) // Dominican Republic 752 DECLARE_COUNTRY(D, Z) // Algeria 753 DECLARE_COUNTRY(E, C) // Ecuador 754 DECLARE_COUNTRY(E, E) // Estonia 755 DECLARE_COUNTRY(E, G) // Egypt 756 DECLARE_COUNTRY(E, S) // Spain 757 DECLARE_COUNTRY(F, I) // Finland 758 DECLARE_COUNTRY(F, O) // Faroe Islands 759 DECLARE_COUNTRY(F, R) // France 760 DECLARE_COUNTRY(G, B) // United Kingdom 761 DECLARE_COUNTRY(G, R) // Greece 762 DECLARE_COUNTRY(G, T) // Guatemala 763 DECLARE_COUNTRY(H, K) // Hong Kong 764 DECLARE_COUNTRY(H, N) // Honduras 765 DECLARE_COUNTRY(H, R) // Croatia 766 DECLARE_COUNTRY(H, U) // Hungary 767 DECLARE_COUNTRY(I, D) // Indonesia 768 DECLARE_COUNTRY(I, E) // Ireland 769 DECLARE_COUNTRY(I, L) // Israel 770 DECLARE_COUNTRY(I, N) // India 771 DECLARE_COUNTRY(I, Q) // Iraq 772 DECLARE_COUNTRY(I, R) // Iran 773 DECLARE_COUNTRY(I, S) // Iceland 774 DECLARE_COUNTRY(I, T) // Italy 775 DECLARE_COUNTRY(J, M) // Jamaica 776 DECLARE_COUNTRY(J, O) // Jordan 777 DECLARE_COUNTRY(J, P) // Japan 778 DECLARE_COUNTRY(K, E) // Kenya 779 DECLARE_COUNTRY(K, R) // South Korea 780 DECLARE_COUNTRY(K, W) // Kuwait 781 DECLARE_COUNTRY(K, Z) // Kazakhstan 782 DECLARE_COUNTRY(L, B) // Lebanon 783 DECLARE_COUNTRY(L, I) // Liechtenstein 784 DECLARE_COUNTRY(L, T) // Lithuania 785 DECLARE_COUNTRY(L, U) // Luxembourg 786 DECLARE_COUNTRY(L, V) // Latvia 787 DECLARE_COUNTRY(L, Y) // Libya 788 DECLARE_COUNTRY(M, A) // Morocco 789 DECLARE_COUNTRY(M, C) // Monaco 790 DECLARE_COUNTRY(M, D) // Moldova 791 DECLARE_COUNTRY(M, E) // Montenegro 792 DECLARE_COUNTRY(M, K) // Macedonia 793 DECLARE_COUNTRY(M, X) // Mexico 794 DECLARE_COUNTRY(M, Y) // Malaysia 795 DECLARE_COUNTRY(N, I) // Nicaragua 796 DECLARE_COUNTRY(N, L) // Netherlands 797 DECLARE_COUNTRY(N, O) // Norway 798 DECLARE_COUNTRY(N, Z) // New Zealand 799 DECLARE_COUNTRY(O, M) // Oman 800 DECLARE_COUNTRY(P, A) // Panama 801 DECLARE_COUNTRY(P, E) // Peru 802 DECLARE_COUNTRY(P, H) // Philippines 803 DECLARE_COUNTRY(P, K) // Pakistan 804 DECLARE_COUNTRY(P, L) // Poland 805 DECLARE_COUNTRY(P, R) // Puerto Rico 806 DECLARE_COUNTRY(P, T) // Portugal 807 DECLARE_COUNTRY(P, Y) // Paraguay 808 DECLARE_COUNTRY(Q, A) // Qatar 809 DECLARE_COUNTRY(R, O) // Romania 810 DECLARE_COUNTRY(R, S) // Serbia 811 DECLARE_COUNTRY(R, U) // Russia 812 DECLARE_COUNTRY(R, W) // Rwanda 813 DECLARE_COUNTRY(S, A) // Saudi Arabia 814 DECLARE_COUNTRY(S, E) // Sweden 815 DECLARE_COUNTRY(S, G) // Singapore 816 DECLARE_COUNTRY(S, I) // Slovenia 817 DECLARE_COUNTRY(S, K) // Slovakia 818 DECLARE_COUNTRY(S, V) // El Salvador 819 DECLARE_COUNTRY(S, Y) // Syria 820 DECLARE_COUNTRY(T, H) // Thailand 821 DECLARE_COUNTRY(T, N) // Tunisia 822 DECLARE_COUNTRY(T, R) // Turkey 823 DECLARE_COUNTRY(T, T) // Trinidad and Tobago 824 DECLARE_COUNTRY(T, W) // Taiwan 825 DECLARE_COUNTRY(T, Z) // Tanzania 826 DECLARE_COUNTRY(U, A) // Ukraine 827 DECLARE_COUNTRY(U, S) // United States 828 DECLARE_COUNTRY(U, Y) // Uruguay 829 DECLARE_COUNTRY(V, E) // Venezuela 830 DECLARE_COUNTRY(V, N) // Vietnam 831 DECLARE_COUNTRY(Y, E) // Yemen 832 DECLARE_COUNTRY(Z, A) // South Africa 833 DECLARE_COUNTRY(Z, W) // Zimbabwe 834 835 // Countries using the "Australia" engine set. 836 UNHANDLED_COUNTRY(C, C) // Cocos Islands 837 UNHANDLED_COUNTRY(C, X) // Christmas Island 838 UNHANDLED_COUNTRY(H, M) // Heard Island and McDonald Islands 839 UNHANDLED_COUNTRY(N, F) // Norfolk Island 840 END_UNHANDLED_COUNTRIES(A, U) 841 842 // Countries using the "China" engine set. 843 UNHANDLED_COUNTRY(M, O) // Macao 844 END_UNHANDLED_COUNTRIES(C, N) 845 846 // Countries using the "Denmark" engine set. 847 UNHANDLED_COUNTRY(G, L) // Greenland 848 END_UNHANDLED_COUNTRIES(D, K) 849 850 // Countries using the "Spain" engine set. 851 UNHANDLED_COUNTRY(A, D) // Andorra 852 END_UNHANDLED_COUNTRIES(E, S) 853 854 // Countries using the "Finland" engine set. 855 UNHANDLED_COUNTRY(A, X) // Aland Islands 856 END_UNHANDLED_COUNTRIES(F, I) 857 858 // Countries using the "France" engine set. 859 UNHANDLED_COUNTRY(B, F) // Burkina Faso 860 UNHANDLED_COUNTRY(B, J) // Benin 861 UNHANDLED_COUNTRY(C, D) // Congo - Kinshasa 862 UNHANDLED_COUNTRY(C, F) // Central African Republic 863 UNHANDLED_COUNTRY(C, G) // Congo - Brazzaville 864 UNHANDLED_COUNTRY(C, I) // Ivory Coast 865 UNHANDLED_COUNTRY(C, M) // Cameroon 866 UNHANDLED_COUNTRY(D, J) // Djibouti 867 UNHANDLED_COUNTRY(G, A) // Gabon 868 UNHANDLED_COUNTRY(G, F) // French Guiana 869 UNHANDLED_COUNTRY(G, N) // Guinea 870 UNHANDLED_COUNTRY(G, P) // Guadeloupe 871 UNHANDLED_COUNTRY(H, T) // Haiti 872 #if defined(OS_WIN) 873 UNHANDLED_COUNTRY(I, P) // Clipperton Island ('IP' is an WinXP-ism; ISO 874 // includes it with France) 875 #endif 876 UNHANDLED_COUNTRY(M, L) // Mali 877 UNHANDLED_COUNTRY(M, Q) // Martinique 878 UNHANDLED_COUNTRY(N, C) // New Caledonia 879 UNHANDLED_COUNTRY(N, E) // Niger 880 UNHANDLED_COUNTRY(P, F) // French Polynesia 881 UNHANDLED_COUNTRY(P, M) // Saint Pierre and Miquelon 882 UNHANDLED_COUNTRY(R, E) // Reunion 883 UNHANDLED_COUNTRY(S, N) // Senegal 884 UNHANDLED_COUNTRY(T, D) // Chad 885 UNHANDLED_COUNTRY(T, F) // French Southern Territories 886 UNHANDLED_COUNTRY(T, G) // Togo 887 UNHANDLED_COUNTRY(W, F) // Wallis and Futuna 888 UNHANDLED_COUNTRY(Y, T) // Mayotte 889 END_UNHANDLED_COUNTRIES(F, R) 890 891 // Countries using the "Greece" engine set. 892 UNHANDLED_COUNTRY(C, Y) // Cyprus 893 END_UNHANDLED_COUNTRIES(G, R) 894 895 // Countries using the "Italy" engine set. 896 UNHANDLED_COUNTRY(S, M) // San Marino 897 UNHANDLED_COUNTRY(V, A) // Vatican 898 END_UNHANDLED_COUNTRIES(I, T) 899 900 // Countries using the "Morocco" engine set. 901 UNHANDLED_COUNTRY(E, H) // Western Sahara 902 END_UNHANDLED_COUNTRIES(M, A) 903 904 // Countries using the "Netherlands" engine set. 905 UNHANDLED_COUNTRY(A, N) // Netherlands Antilles 906 UNHANDLED_COUNTRY(A, W) // Aruba 907 END_UNHANDLED_COUNTRIES(N, L) 908 909 // Countries using the "Norway" engine set. 910 UNHANDLED_COUNTRY(B, V) // Bouvet Island 911 UNHANDLED_COUNTRY(S, J) // Svalbard and Jan Mayen 912 END_UNHANDLED_COUNTRIES(N, O) 913 914 // Countries using the "New Zealand" engine set. 915 UNHANDLED_COUNTRY(C, K) // Cook Islands 916 UNHANDLED_COUNTRY(N, U) // Niue 917 UNHANDLED_COUNTRY(T, K) // Tokelau 918 END_UNHANDLED_COUNTRIES(N, Z) 919 920 // Countries using the "Portugal" engine set. 921 UNHANDLED_COUNTRY(C, V) // Cape Verde 922 UNHANDLED_COUNTRY(G, W) // Guinea-Bissau 923 UNHANDLED_COUNTRY(M, Z) // Mozambique 924 UNHANDLED_COUNTRY(S, T) // Sao Tome and Principe 925 UNHANDLED_COUNTRY(T, L) // Timor-Leste 926 END_UNHANDLED_COUNTRIES(P, T) 927 928 // Countries using the "Russia" engine set. 929 UNHANDLED_COUNTRY(A, M) // Armenia 930 UNHANDLED_COUNTRY(A, Z) // Azerbaijan 931 UNHANDLED_COUNTRY(K, G) // Kyrgyzstan 932 UNHANDLED_COUNTRY(T, J) // Tajikistan 933 UNHANDLED_COUNTRY(T, M) // Turkmenistan 934 UNHANDLED_COUNTRY(U, Z) // Uzbekistan 935 END_UNHANDLED_COUNTRIES(R, U) 936 937 // Countries using the "Saudi Arabia" engine set. 938 UNHANDLED_COUNTRY(M, R) // Mauritania 939 UNHANDLED_COUNTRY(P, S) // Palestinian Territory 940 UNHANDLED_COUNTRY(S, D) // Sudan 941 END_UNHANDLED_COUNTRIES(S, A) 942 943 // Countries using the "United Kingdom" engine set. 944 UNHANDLED_COUNTRY(B, M) // Bermuda 945 UNHANDLED_COUNTRY(F, K) // Falkland Islands 946 UNHANDLED_COUNTRY(G, G) // Guernsey 947 UNHANDLED_COUNTRY(G, I) // Gibraltar 948 UNHANDLED_COUNTRY(G, S) // South Georgia and the South Sandwich 949 // Islands 950 UNHANDLED_COUNTRY(I, M) // Isle of Man 951 UNHANDLED_COUNTRY(I, O) // British Indian Ocean Territory 952 UNHANDLED_COUNTRY(J, E) // Jersey 953 UNHANDLED_COUNTRY(K, Y) // Cayman Islands 954 UNHANDLED_COUNTRY(M, S) // Montserrat 955 UNHANDLED_COUNTRY(M, T) // Malta 956 UNHANDLED_COUNTRY(P, N) // Pitcairn Islands 957 UNHANDLED_COUNTRY(S, H) // Saint Helena, Ascension Island, and Tristan da 958 // Cunha 959 UNHANDLED_COUNTRY(T, C) // Turks and Caicos Islands 960 UNHANDLED_COUNTRY(V, G) // British Virgin Islands 961 END_UNHANDLED_COUNTRIES(G, B) 962 963 // Countries using the "United States" engine set. 964 UNHANDLED_COUNTRY(A, S) // American Samoa 965 UNHANDLED_COUNTRY(G, U) // Guam 966 UNHANDLED_COUNTRY(M, P) // Northern Mariana Islands 967 UNHANDLED_COUNTRY(U, M) // U.S. Minor Outlying Islands 968 UNHANDLED_COUNTRY(V, I) // U.S. Virgin Islands 969 END_UNHANDLED_COUNTRIES(U, S) 970 971 // Countries using the "default" engine set. 972 UNHANDLED_COUNTRY(A, F) // Afghanistan 973 UNHANDLED_COUNTRY(A, G) // Antigua and Barbuda 974 UNHANDLED_COUNTRY(A, I) // Anguilla 975 UNHANDLED_COUNTRY(A, O) // Angola 976 UNHANDLED_COUNTRY(A, Q) // Antarctica 977 UNHANDLED_COUNTRY(B, B) // Barbados 978 UNHANDLED_COUNTRY(B, D) // Bangladesh 979 UNHANDLED_COUNTRY(B, S) // Bahamas 980 UNHANDLED_COUNTRY(B, T) // Bhutan 981 UNHANDLED_COUNTRY(B, W) // Botswana 982 UNHANDLED_COUNTRY(C, U) // Cuba 983 UNHANDLED_COUNTRY(D, M) // Dominica 984 UNHANDLED_COUNTRY(E, R) // Eritrea 985 UNHANDLED_COUNTRY(E, T) // Ethiopia 986 UNHANDLED_COUNTRY(F, J) // Fiji 987 UNHANDLED_COUNTRY(F, M) // Micronesia 988 UNHANDLED_COUNTRY(G, D) // Grenada 989 UNHANDLED_COUNTRY(G, E) // Georgia 990 UNHANDLED_COUNTRY(G, H) // Ghana 991 UNHANDLED_COUNTRY(G, M) // Gambia 992 UNHANDLED_COUNTRY(G, Q) // Equatorial Guinea 993 UNHANDLED_COUNTRY(G, Y) // Guyana 994 UNHANDLED_COUNTRY(K, H) // Cambodia 995 UNHANDLED_COUNTRY(K, I) // Kiribati 996 UNHANDLED_COUNTRY(K, M) // Comoros 997 UNHANDLED_COUNTRY(K, N) // Saint Kitts and Nevis 998 UNHANDLED_COUNTRY(K, P) // North Korea 999 UNHANDLED_COUNTRY(L, A) // Laos 1000 UNHANDLED_COUNTRY(L, C) // Saint Lucia 1001 UNHANDLED_COUNTRY(L, K) // Sri Lanka 1002 UNHANDLED_COUNTRY(L, R) // Liberia 1003 UNHANDLED_COUNTRY(L, S) // Lesotho 1004 UNHANDLED_COUNTRY(M, G) // Madagascar 1005 UNHANDLED_COUNTRY(M, H) // Marshall Islands 1006 UNHANDLED_COUNTRY(M, M) // Myanmar 1007 UNHANDLED_COUNTRY(M, N) // Mongolia 1008 UNHANDLED_COUNTRY(M, U) // Mauritius 1009 UNHANDLED_COUNTRY(M, V) // Maldives 1010 UNHANDLED_COUNTRY(M, W) // Malawi 1011 UNHANDLED_COUNTRY(N, A) // Namibia 1012 UNHANDLED_COUNTRY(N, G) // Nigeria 1013 UNHANDLED_COUNTRY(N, P) // Nepal 1014 UNHANDLED_COUNTRY(N, R) // Nauru 1015 UNHANDLED_COUNTRY(P, G) // Papua New Guinea 1016 UNHANDLED_COUNTRY(P, W) // Palau 1017 UNHANDLED_COUNTRY(S, B) // Solomon Islands 1018 UNHANDLED_COUNTRY(S, C) // Seychelles 1019 UNHANDLED_COUNTRY(S, L) // Sierra Leone 1020 UNHANDLED_COUNTRY(S, O) // Somalia 1021 UNHANDLED_COUNTRY(S, R) // Suriname 1022 UNHANDLED_COUNTRY(S, Z) // Swaziland 1023 UNHANDLED_COUNTRY(T, O) // Tonga 1024 UNHANDLED_COUNTRY(T, V) // Tuvalu 1025 UNHANDLED_COUNTRY(U, G) // Uganda 1026 UNHANDLED_COUNTRY(V, C) // Saint Vincent and the Grenadines 1027 UNHANDLED_COUNTRY(V, U) // Vanuatu 1028 UNHANDLED_COUNTRY(W, S) // Samoa 1029 UNHANDLED_COUNTRY(Z, M) // Zambia 1030 case kCountryIDUnknown: 1031 default: // Unhandled location 1032 END_UNHANDLED_COUNTRIES(def, ault) 1033 } 1034 } 1035 1036 scoped_ptr<TemplateURLData> MakePrepopulatedTemplateURLData( 1037 const base::string16& name, 1038 const base::string16& keyword, 1039 const base::StringPiece& search_url, 1040 const base::StringPiece& suggest_url, 1041 const base::StringPiece& instant_url, 1042 const base::StringPiece& image_url, 1043 const base::StringPiece& new_tab_url, 1044 const base::StringPiece& contextual_search_url, 1045 const base::StringPiece& search_url_post_params, 1046 const base::StringPiece& suggest_url_post_params, 1047 const base::StringPiece& instant_url_post_params, 1048 const base::StringPiece& image_url_post_params, 1049 const base::StringPiece& favicon_url, 1050 const base::StringPiece& encoding, 1051 const base::ListValue& alternate_urls, 1052 const base::StringPiece& search_terms_replacement_key, 1053 int id) { 1054 scoped_ptr<TemplateURLData> data(new TemplateURLData); 1055 1056 data->short_name = name; 1057 data->SetKeyword(keyword); 1058 data->SetURL(search_url.as_string()); 1059 data->suggestions_url = suggest_url.as_string(); 1060 data->instant_url = instant_url.as_string(); 1061 data->image_url = image_url.as_string(); 1062 data->new_tab_url = new_tab_url.as_string(); 1063 data->contextual_search_url = contextual_search_url.as_string(); 1064 data->search_url_post_params = search_url_post_params.as_string(); 1065 data->suggestions_url_post_params = suggest_url_post_params.as_string(); 1066 data->instant_url_post_params = instant_url_post_params.as_string(); 1067 data->image_url_post_params = image_url_post_params.as_string(); 1068 data->favicon_url = GURL(favicon_url.as_string()); 1069 data->show_in_default_list = true; 1070 data->safe_for_autoreplace = true; 1071 data->input_encodings.push_back(encoding.as_string()); 1072 data->date_created = base::Time(); 1073 data->last_modified = base::Time(); 1074 data->prepopulate_id = id; 1075 for (size_t i = 0; i < alternate_urls.GetSize(); ++i) { 1076 std::string alternate_url; 1077 alternate_urls.GetString(i, &alternate_url); 1078 DCHECK(!alternate_url.empty()); 1079 data->alternate_urls.push_back(alternate_url); 1080 } 1081 data->search_terms_replacement_key = search_terms_replacement_key.as_string(); 1082 return data.Pass(); 1083 } 1084 1085 ScopedVector<TemplateURLData> GetPrepopulatedTemplateURLData( 1086 PrefService* prefs) { 1087 ScopedVector<TemplateURLData> t_urls; 1088 if (!prefs) 1089 return t_urls.Pass(); 1090 1091 const base::ListValue* list = prefs->GetList(prefs::kSearchProviderOverrides); 1092 if (!list) 1093 return t_urls.Pass(); 1094 1095 size_t num_engines = list->GetSize(); 1096 for (size_t i = 0; i != num_engines; ++i) { 1097 const base::DictionaryValue* engine; 1098 base::string16 name; 1099 base::string16 keyword; 1100 std::string search_url; 1101 std::string favicon_url; 1102 std::string encoding; 1103 int id = -1; 1104 // The following fields are required for each search engine configuration. 1105 if (list->GetDictionary(i, &engine) && 1106 engine->GetString("name", &name) && !name.empty() && 1107 engine->GetString("keyword", &keyword) && !keyword.empty() && 1108 engine->GetString("search_url", &search_url) && !search_url.empty() && 1109 engine->GetString("favicon_url", &favicon_url) && 1110 !favicon_url.empty() && 1111 engine->GetString("encoding", &encoding) && !encoding.empty() && 1112 engine->GetInteger("id", &id)) { 1113 // These fields are optional. 1114 std::string suggest_url; 1115 std::string instant_url; 1116 std::string image_url; 1117 std::string new_tab_url; 1118 std::string contextual_search_url; 1119 std::string search_url_post_params; 1120 std::string suggest_url_post_params; 1121 std::string instant_url_post_params; 1122 std::string image_url_post_params; 1123 base::ListValue empty_list; 1124 const base::ListValue* alternate_urls = &empty_list; 1125 std::string search_terms_replacement_key; 1126 engine->GetString("suggest_url", &suggest_url); 1127 engine->GetString("instant_url", &instant_url); 1128 engine->GetString("image_url", &image_url); 1129 engine->GetString("new_tab_url", &new_tab_url); 1130 engine->GetString("contextual_search_url", &contextual_search_url); 1131 engine->GetString("search_url_post_params", &search_url_post_params); 1132 engine->GetString("suggest_url_post_params", &suggest_url_post_params); 1133 engine->GetString("instant_url_post_params", &instant_url_post_params); 1134 engine->GetString("image_url_post_params", &image_url_post_params); 1135 engine->GetList("alternate_urls", &alternate_urls); 1136 engine->GetString("search_terms_replacement_key", 1137 &search_terms_replacement_key); 1138 t_urls.push_back(MakePrepopulatedTemplateURLData(name, keyword, 1139 search_url, suggest_url, instant_url, image_url, new_tab_url, 1140 contextual_search_url, search_url_post_params, 1141 suggest_url_post_params, instant_url_post_params, 1142 image_url_post_params, favicon_url, encoding, *alternate_urls, 1143 search_terms_replacement_key, id).release()); 1144 } 1145 } 1146 return t_urls.Pass(); 1147 } 1148 1149 scoped_ptr<TemplateURLData> 1150 MakePrepopulatedTemplateURLDataFromPrepopulateEngine( 1151 const PrepopulatedEngine& engine) { 1152 base::ListValue alternate_urls; 1153 if (engine.alternate_urls) { 1154 for (size_t i = 0; i < engine.alternate_urls_size; ++i) 1155 alternate_urls.AppendString(std::string(engine.alternate_urls[i])); 1156 } 1157 1158 return MakePrepopulatedTemplateURLData(base::WideToUTF16(engine.name), 1159 base::WideToUTF16(engine.keyword), 1160 engine.search_url, 1161 engine.suggest_url, 1162 engine.instant_url, 1163 engine.image_url, 1164 engine.new_tab_url, 1165 engine.contextual_search_url, 1166 engine.search_url_post_params, 1167 engine.suggest_url_post_params, 1168 engine.instant_url_post_params, 1169 engine.image_url_post_params, 1170 engine.favicon_url, 1171 engine.encoding, 1172 alternate_urls, 1173 engine.search_terms_replacement_key, 1174 engine.id); 1175 } 1176 1177 bool SameDomain(const GURL& given_url, const GURL& prepopulated_url) { 1178 return prepopulated_url.is_valid() && 1179 net::registry_controlled_domains::SameDomainOrHost( 1180 given_url, prepopulated_url, 1181 net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); 1182 } 1183 1184 } // namespace 1185 1186 1187 // Global functions ----------------------------------------------------------- 1188 1189 #if defined(OS_ANDROID) 1190 void InitCountryCode(const std::string& country_code) { 1191 if (country_code.size() != 2) { 1192 DLOG(ERROR) << "Invalid country code: " << country_code; 1193 g_country_code_at_install = kCountryIDUnknown; 1194 } else { 1195 g_country_code_at_install = 1196 CountryCharsToCountryIDWithUpdate(country_code[0], country_code[1]); 1197 } 1198 } 1199 #endif 1200 1201 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) { 1202 registry->RegisterIntegerPref( 1203 prefs::kCountryIDAtInstall, 1204 kCountryIDUnknown, 1205 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 1206 registry->RegisterListPref(prefs::kSearchProviderOverrides, 1207 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 1208 registry->RegisterIntegerPref( 1209 prefs::kSearchProviderOverridesVersion, 1210 -1, 1211 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 1212 } 1213 1214 int GetDataVersion(PrefService* prefs) { 1215 // Allow tests to override the local version. 1216 return (prefs && prefs->HasPrefPath(prefs::kSearchProviderOverridesVersion)) ? 1217 prefs->GetInteger(prefs::kSearchProviderOverridesVersion) : 1218 kCurrentDataVersion; 1219 } 1220 1221 ScopedVector<TemplateURLData> GetPrepopulatedEngines( 1222 PrefService* prefs, 1223 size_t* default_search_provider_index) { 1224 // If there is a set of search engines in the preferences file, it overrides 1225 // the built-in set. 1226 *default_search_provider_index = 0; 1227 ScopedVector<TemplateURLData> t_urls = GetPrepopulatedTemplateURLData(prefs); 1228 if (!t_urls.empty()) 1229 return t_urls.Pass(); 1230 1231 const PrepopulatedEngine** engines; 1232 size_t num_engines; 1233 GetPrepopulationSetFromCountryID(prefs, &engines, &num_engines); 1234 for (size_t i = 0; i != num_engines; ++i) { 1235 t_urls.push_back(MakePrepopulatedTemplateURLDataFromPrepopulateEngine( 1236 *engines[i]).release()); 1237 } 1238 return t_urls.Pass(); 1239 } 1240 1241 void ClearPrepopulatedEnginesInPrefs(PrefService* prefs) { 1242 if (!prefs) 1243 return; 1244 1245 prefs->ClearPref(prefs::kSearchProviderOverrides); 1246 prefs->ClearPref(prefs::kSearchProviderOverridesVersion); 1247 } 1248 1249 scoped_ptr<TemplateURLData> GetPrepopulatedDefaultSearch(PrefService* prefs) { 1250 scoped_ptr<TemplateURLData> default_search_provider; 1251 size_t default_search_index; 1252 // This could be more efficient. We are loading all the URLs to only keep 1253 // the first one. 1254 ScopedVector<TemplateURLData> loaded_urls = 1255 GetPrepopulatedEngines(prefs, &default_search_index); 1256 if (default_search_index < loaded_urls.size()) { 1257 default_search_provider.reset(loaded_urls[default_search_index]); 1258 loaded_urls.weak_erase(loaded_urls.begin() + default_search_index); 1259 } 1260 return default_search_provider.Pass(); 1261 } 1262 1263 SearchEngineType GetEngineType(const TemplateURL& url, 1264 const SearchTermsData& search_terms_data) { 1265 // By calling ReplaceSearchTerms, we ensure that even TemplateURLs whose URLs 1266 // can't be directly inspected (e.g. due to containing {google:baseURL}) can 1267 // be converted to GURLs we can look at. 1268 GURL gurl(url.url_ref().ReplaceSearchTerms(TemplateURLRef::SearchTermsArgs( 1269 base::ASCIIToUTF16("x")), search_terms_data)); 1270 return gurl.is_valid() ? GetEngineType(gurl) : SEARCH_ENGINE_OTHER; 1271 } 1272 1273 SearchEngineType GetEngineType(const GURL& url) { 1274 DCHECK(url.is_valid()); 1275 1276 // Check using TLD+1s, in order to more aggressively match search engine types 1277 // for data imported from other browsers. 1278 // 1279 // First special-case Google, because the prepopulate URL for it will not 1280 // convert to a GURL and thus won't have an origin. Instead see if the 1281 // incoming URL's host is "[*.]google.<TLD>". 1282 if (google_util::IsGoogleHostname(url.host(), 1283 google_util::DISALLOW_SUBDOMAIN)) 1284 return google.type; 1285 1286 // Now check the rest of the prepopulate data. 1287 for (size_t i = 0; i < arraysize(kAllEngines); ++i) { 1288 // First check the main search URL. 1289 if (SameDomain(url, GURL(kAllEngines[i]->search_url))) 1290 return kAllEngines[i]->type; 1291 1292 // Then check the alternate URLs. 1293 for (size_t j = 0; j < kAllEngines[i]->alternate_urls_size; ++j) { 1294 if (SameDomain(url, GURL(kAllEngines[i]->alternate_urls[j]))) 1295 return kAllEngines[i]->type; 1296 } 1297 } 1298 1299 return SEARCH_ENGINE_OTHER; 1300 } 1301 1302 } // namespace TemplateURLPrepopulateData 1303
