Create TemplateUrlData to base::Dictionary utility functions

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
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/prepopulated_engines.h"
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/search_engines/template_url_data.h"
+#include "components/search_engines/template_url_data_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/gurl.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
 
 #if defined(OS_ANDROID)
@@ skipping 931 matching lines @@
     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]));
+    t_urls.push_back(TemplateURLDataFromPrepopulatedEngine(*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,
-    const base::StringPiece& contextual_search_url,
-    const base::StringPiece& search_url_post_params,
-    const base::StringPiece& suggest_url_post_params,
-    const base::StringPiece& instant_url_post_params,
-    const base::StringPiece& image_url_post_params,
-    const base::StringPiece& favicon_url,
-    const base::StringPiece& encoding,
-    const base::ListValue& alternate_urls,
-    const base::StringPiece& search_terms_replacement_key,
-    int id) {
-  std::unique_ptr<TemplateURLData> data(new TemplateURLData);
-
-  data->SetShortName(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->image_url = image_url.as_string();
-  data->new_tab_url = new_tab_url.as_string();
-  data->contextual_search_url = contextual_search_url.as_string();
-  data->search_url_post_params = search_url_post_params.as_string();
-  data->suggestions_url_post_params = suggest_url_post_params.as_string();
-  data->instant_url_post_params = instant_url_post_params.as_string();
-  data->image_url_post_params = image_url_post_params.as_string();
-  data->favicon_url = GURL(favicon_url);
-  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 data;
-}
-
 std::vector<std::unique_ptr<TemplateURLData>> GetPrepopulatedTemplateURLData(
     PrefService* prefs) {
   std::vector<std::unique_ptr<TemplateURLData>> t_urls;
   if (!prefs)
     return t_urls;
 
   const base::ListValue* list = prefs->GetList(prefs::kSearchProviderOverrides);
   if (!list)
     return t_urls;
 
   size_t num_engines = list->GetSize();
   for (size_t i = 0; i != num_engines; ++i) {
     const base::DictionaryValue* engine;
-    base::string16 name;
-    base::string16 keyword;
-    std::string search_url;
-    std::string favicon_url;
-    std::string encoding;
-    int id = -1;
-    // The following fields are required for each search engine configuration.
+    std::unique_ptr<TemplateURLData> t_url;
     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;
-      std::string image_url;
-      std::string new_tab_url;
-      std::string contextual_search_url;
-      std::string search_url_post_params;
-      std::string suggest_url_post_params;
-      std::string instant_url_post_params;
-      std::string image_url_post_params;
-      base::ListValue empty_list;
-      const base::ListValue* alternate_urls = &empty_list;
-      std::string search_terms_replacement_key;
-      engine->GetString("suggest_url", &suggest_url);
-      engine->GetString("instant_url", &instant_url);
-      engine->GetString("image_url", &image_url);
-      engine->GetString("new_tab_url", &new_tab_url);
-      engine->GetString("contextual_search_url", &contextual_search_url);
-      engine->GetString("search_url_post_params", &search_url_post_params);
-      engine->GetString("suggest_url_post_params", &suggest_url_post_params);
-      engine->GetString("instant_url_post_params", &instant_url_post_params);
-      engine->GetString("image_url_post_params", &image_url_post_params);
-      engine->GetList("alternate_urls", &alternate_urls);
-      engine->GetString("search_terms_replacement_key",
-          &search_terms_replacement_key);
-      t_urls.push_back(MakePrepopulatedTemplateURLData(
-          name, keyword, search_url, suggest_url, instant_url, image_url,
-          new_tab_url, contextual_search_url, search_url_post_params,
-          suggest_url_post_params, instant_url_post_params,
-          image_url_post_params, favicon_url, encoding, *alternate_urls,
-          search_terms_replacement_key, id));
-    }
+        (t_url = TemplateURLDataFromOverrideDictionary(*engine)))

[Peter Kasting, 2016/11/20 07:57:50]

Nit: Don't use statements with side effects in conditionals.  Fixing this will
also allow you to narrow the scope of |t_url| (see
http://google.github.io/styleguide/cppguide.html#Local_Variables ):

    if (list->GetDictionary(i, &engine)) {
      auto t_url = TemplateURLDataFromOverrideDictionary(*engine);
      if (t_url)
        t_urls.push_back(std::move(t_url));
    }

[Alexander Yashkin, 2016/11/20 20:24:05]

Thanks, fixed.

+      t_urls.push_back(std::move(t_url));
   }
   return t_urls;
 }
 
 bool SameDomain(const GURL& given_url, const GURL& prepopulated_url) {
   return prepopulated_url.is_valid() &&
       net::registry_controlled_domains::SameDomainOrHost(
           given_url, prepopulated_url,
           net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
 }
@@ skipping 41 matching lines @@
 
   return GetPrepopulationSetFromCountryID(country_id);
 }
 #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) {
-    for (size_t i = 0; i < engine.alternate_urls_size; ++i)
-      alternate_urls.AppendString(std::string(engine.alternate_urls[i]));
-  }
-
-  return MakePrepopulatedTemplateURLData(
-      base::WideToUTF16(engine.name), base::WideToUTF16(engine.keyword),
-      engine.search_url, engine.suggest_url, engine.instant_url,
-      engine.image_url, engine.new_tab_url, engine.contextual_search_url,
-      engine.search_url_post_params, engine.suggest_url_post_params,
-      engine.instant_url_post_params, engine.image_url_post_params,
-      engine.favicon_url, engine.encoding, alternate_urls,
-      engine.search_terms_replacement_key, engine.id);
-}
-
 void ClearPrepopulatedEnginesInPrefs(PrefService* prefs) {
   if (!prefs)
     return;
 
   prefs->ClearPref(prefs::kSearchProviderOverrides);
   prefs->ClearPref(prefs::kSearchProviderOverridesVersion);
 }
 
 std::unique_ptr<TemplateURLData> GetPrepopulatedDefaultSearch(
     PrefService* prefs) {
@@ skipping 85 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