Cache SearchEngineType of TemplateURL

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/stl_util.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.h"
+#include "components/search_engines/template_url_data.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 943 matching lines @@
     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,
+    SearchEngineType engine_type,
     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.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->engine_type = engine_type;
   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;
 }
@@ skipping 44 matching lines @@
       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);
+      const SearchEngineType type = SEARCH_ENGINE_UNKNOWN;

[Peter Kasting, 2016/05/17 04:43:04]

Nit: Inline into next statement

[Vitaly Baranov, 2016/06/03 15:31:45]

Done.

       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).release());
+          search_terms_replacement_key, type, id).release());
     }
   }
   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 44 matching lines @@
       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);
+      engine.search_terms_replacement_key, engine.type, engine.id);
 }
 
 void ClearPrepopulatedEnginesInPrefs(PrefService* prefs) {
   if (!prefs)
     return;
 
   prefs->ClearPref(prefs::kSearchProviderOverrides);
   prefs->ClearPref(prefs::kSearchProviderOverridesVersion);
 }
 
 std::unique_ptr<TemplateURLData> GetPrepopulatedDefaultSearch(
     PrefService* prefs) {
   std::unique_ptr<TemplateURLData> default_search_provider;
   size_t default_search_index;
   // This could be more efficient.  We are loading all the URLs to only keep
   // the first one.
   ScopedVector<TemplateURLData> loaded_urls =
       GetPrepopulatedEngines(prefs, &default_search_index);
   if (default_search_index < loaded_urls.size()) {
     default_search_provider.reset(loaded_urls[default_search_index]);
     loaded_urls.weak_erase(loaded_urls.begin() + default_search_index);
   }
   return default_search_provider;
 }
 
-SearchEngineType GetEngineType(const TemplateURL& url,
-                               const SearchTermsData& search_terms_data) {
-  // By calling ReplaceSearchTerms, we ensure that even TemplateURLs whose URLs
-  // can't be directly inspected (e.g. due to containing {google:baseURL}) can
-  // be converted to GURLs we can look at.
-  GURL gurl(url.url_ref().ReplaceSearchTerms(TemplateURLRef::SearchTermsArgs(
-      base::ASCIIToUTF16("x")), search_terms_data));
-  return gurl.is_valid() ? GetEngineType(gurl) : SEARCH_ENGINE_OTHER;
-}
-
 SearchEngineType GetEngineType(const GURL& url) {
   DCHECK(url.is_valid());
 
   // Check using TLD+1s, 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(url.host(),
@@ skipping 77 matching lines @@
         base::ToUpperASCII(locale_str[begin]),
         base::ToUpperASCII(locale_str[begin + 1]));
   }
 
   return kCountryIDUnknown;
 }
 
 #endif  // OS_*
 
 }  // namespace TemplateURLPrepopulateData