components/search_engines/template_url_prepopulate_data.cc

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