Add a Profile* member to TemplateURL. This makes some invocations of ReplaceSearchTerms() a bit le…

chrome/browser/search_engines/template_url_prepopulate_data.cc

 // 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
 
@@ skipping 3132 matching lines @@
   const int kCurrentDataVersion = 38;
   if (!prefs)
     return kCurrentDataVersion;
   // If a version number exist in the preferences file, it overrides the
   // version of the built-in data.
   int version =
     prefs->GetInteger(prefs::kSearchProviderOverridesVersion);
   return (version >= 0) ? version : kCurrentDataVersion;
 }
 
-TemplateURL* MakePrepopulatedTemplateURL(const string16& name,
+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,
                                          int id) {
   TemplateURLData data;
   data.short_name = name;
   if (keyword.empty())
     data.SetAutogenerateKeyword(true);
   else
     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;
-  return new TemplateURL(data);
+  return new TemplateURL(profile, data);
 }
 
-void GetPrepopulatedTemplateFromPrefs(PrefService* prefs,
+void GetPrepopulatedTemplateFromPrefs(Profile* profile,
                                       std::vector<TemplateURL*>* t_urls) {
-  if (!prefs)
+  if (!profile)
     return;
 
   const ListValue* list =
-      prefs->GetList(prefs::kSearchProviderOverrides);
+      profile->GetPrefs()->GetList(prefs::kSearchProviderOverrides);
   if (!list)
     return;
 
   string16 name;
   string16 keyword;
   std::string search_url;
   std::string suggest_url;
   std::string instant_url;
   std::string favicon_url;
   std::string encoding;
@@ skipping 13 matching lines @@
         engine->Get("encoding", &val) && val->GetAsString(&encoding) &&
         engine->Get("id", &val) && val->GetAsInteger(&id)) {
       // These next fields are not allowed to be empty.
       if (name.empty() || search_url.empty() || favicon_url.empty() ||
           encoding.empty())
         return;
     } else {
       // Got a parsing error. No big deal.
       continue;
     }
-    t_urls->push_back(MakePrepopulatedTemplateURL(name, keyword, search_url,
-        suggest_url, instant_url, favicon_url, encoding, id));
+    t_urls->push_back(MakePrepopulatedTemplateURL(profile, name, keyword,
+        search_url, suggest_url, instant_url, favicon_url, encoding, id));
   }
 }
 
 // The caller owns the returned TemplateURL.
 TemplateURL* MakePrepopulatedTemplateURLFromPrepopulateEngine(
+    Profile* profile,
     const PrepopulatedEngine& engine) {
-  return MakePrepopulatedTemplateURL(WideToUTF16(engine.name),
+  return MakePrepopulatedTemplateURL(profile, WideToUTF16(engine.name),
       WideToUTF16(engine.keyword), engine.search_url, engine.suggest_url,
       engine.instant_url, engine.favicon_url, engine.encoding, engine.id);
 }
 
-void GetPrepopulatedEngines(PrefService* prefs,
+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(prefs, t_urls);
+  GetPrepopulatedTemplateFromPrefs(profile, t_urls);
   if (!t_urls->empty())
     return;
 
   const PrepopulatedEngine** engines;
   size_t num_engines;
-  GetPrepopulationSetFromCountryID(prefs, &engines, &num_engines);
+  GetPrepopulationSetFromCountryID(profile ? profile->GetPrefs() : NULL,
+                                   &engines, &num_engines);
   for (size_t i = 0; i != num_engines; ++i) {
     t_urls->push_back(
-        MakePrepopulatedTemplateURLFromPrepopulateEngine(*engines[i]));
+        MakePrepopulatedTemplateURLFromPrepopulateEngine(profile, *engines[i]));
   }
 }
 
-TemplateURL* GetPrepopulatedDefaultSearch(PrefService* prefs) {
+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(prefs, &loaded_urls.get(), &default_search_index);
+  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;
 }
 
 static const PrepopulatedEngine* GetEngineForURL(const std::string& url) {
   // We may get a valid URL, or we may get the Google prepopulate URL which
   // can't be converted to a GURL.  Instead of forcing callers to substitute to
@@ skipping 35 matching lines @@
       UTF8ToUTF16(as_gurl.host()) :
       l10n_util::GetStringUTF16(IDS_UNKNOWN_SEARCH_ENGINE_NAME);
 }
 
 SearchEngineType GetEngineType(const std::string& url) {
   const PrepopulatedEngine* engine = GetEngineForURL(url);
   return engine ? engine->type : SEARCH_ENGINE_OTHER;
 }
 
 }  // namespace TemplateURLPrepopulateData