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