Enable Chrome to tweak search engines for some locales

components/search_engines/template_url_prepopulate_data.cc

 // Copyright 2014 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 "components/search_engines/template_url_prepopulate_data.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include <locale.h>
 #endif
 
@@ skipping 597 matching lines @@
   // 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->HasPrefPath(prefs::kCountryIDAtInstall)) {
     prefs->SetInteger(prefs::kCountryIDAtInstall, GetCurrentCountryID());
   }
   return prefs->GetInteger(prefs::kCountryIDAtInstall);
 }
 
-void GetPrepopulationSetFromCountryID(PrefService* prefs,
-                                      const PrepopulatedEngine*** engines,
-                                      size_t* num_engines) {
-  // NOTE: This function should ALWAYS set its outparams.
-
+std::vector<std::unique_ptr<TemplateURLData>> GetPrepopulationSetFromCountryID(
+    int country_id) {
+  const PrepopulatedEngine** engines;
+  size_t num_engines;
   // If you add a new country make sure to update the unit test for coverage.
-  switch (GetCountryIDFromPrefs(prefs)) {
-
+  switch (country_id) {
 #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'
@@ skipping 13 matching lines @@
 #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;
+      engines = engines_##code1##code2;\
+      num_engines = arraysize(engines_##code1##code2);\
+      break;
 #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
@@ skipping 292 matching lines @@
     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)
   }
+
+  std::vector<std::unique_ptr<TemplateURLData>> t_urls;
+  for (size_t i = 0; i < num_engines; ++i)
+    t_urls.push_back(MakeTemplateURLDataFromPrepopulatedEngine(*engines[i]));
+  return t_urls;
 }
 
 std::unique_ptr<TemplateURLData> MakePrepopulatedTemplateURLData(
     const base::string16& name,
     const base::string16& keyword,
     const base::StringPiece& search_url,
     const base::StringPiece& suggest_url,
     const base::StringPiece& instant_url,
     const base::StringPiece& image_url,
     const base::StringPiece& new_tab_url,
@@ skipping 130 matching lines @@
     PrefService* prefs,
     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;
   std::vector<std::unique_ptr<TemplateURLData>> t_urls =
       GetPrepopulatedTemplateURLData(prefs);
   if (!t_urls.empty())
     return t_urls;
 
-  const PrepopulatedEngine** engines;
-  size_t num_engines;
-  GetPrepopulationSetFromCountryID(prefs, &engines, &num_engines);
-  for (size_t i = 0; i != num_engines; ++i) {
-    t_urls.push_back(MakeTemplateURLDataFromPrepopulatedEngine(*engines[i]));
+  return GetPrepopulationSetFromCountryID(GetCountryIDFromPrefs(prefs));
+}
+
+#if defined(OS_ANDROID)
+std::vector<std::unique_ptr<TemplateURLData>> GetLocalPrepopulatedEngines(
+    const std::string& locale,
+    PrefService* prefs) {
+  int country_id = CountryStringToCountryID(locale);
+  if (country_id == kCountryIDUnknown ||
+      country_id == GetCountryIDFromPrefs(prefs)) {
+    return std::vector<std::unique_ptr<TemplateURLData>>();
   }
-  return t_urls;
+
+  return GetPrepopulationSetFromCountryID(country_id);

[Alexander Yashkin, 2016/10/21 06:34:41]

Is it ok, that GetLocalPrepopulatedEngines returns list of prepopulated engines
for locale and do not take in consideration 
engines that were overriden from preference file like its done in
GetPrepopulatedEngines?

[Peter Kasting, 2016/10/21 06:44:42]

What do you mean "is it OK"?  This is a utility function, so the question is
what the overall system is doing, not just what this function is doing.  What
does the caller need to take into account?  What preferences are in question
here?  Or to step back: what problem are you seeing that needs solving?

 }
+#endif
 
 std::vector<const PrepopulatedEngine*> GetAllPrepopulatedEngines() {
   return std::vector<const PrepopulatedEngine*>(std::begin(kAllEngines),
                                                 std::end(kAllEngines));
 }
 
 std::unique_ptr<TemplateURLData> MakeTemplateURLDataFromPrepopulatedEngine(
     const PrepopulatedEngine& engine) {
   base::ListValue alternate_urls;
   if (engine.alternate_urls) {
@@ skipping 109 matching lines @@
   locale_str.erase(0, territory_delim + 1);
 
   // Next remove any codeset/modifier portion and uppercase.
   return CountryStringToCountryID(
       base::ToUpperASCII(locale_str.substr(0, locale_str.find_first_of(".@"))));
 }
 
 #endif  // OS_*
 
 }  // namespace TemplateURLPrepopulateData