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

chrome/browser/search_engines/template_url_service.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_service.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 307 matching lines @@
   return (initial_default_search_provider_.get() &&
       (GenerateSearchURL(initial_default_search_provider_.get()).host() ==
           host)) ? initial_default_search_provider_.get() : NULL;
 }
 
 void TemplateURLService::Add(TemplateURL* template_url) {
   AddNoNotify(template_url, true);
   NotifyObservers();
 }
 
+void TemplateURLService::AddAndSetProfile(TemplateURL* template_url,
+                                          Profile* profile) {
+  template_url->profile_ = profile;
+  Add(template_url);
+}
+
 void TemplateURLService::AddWithOverrides(const TemplateURL* template_url,
                                           const string16& short_name,
                                           const string16& keyword,
                                           const std::string& url) {
   DCHECK(!url.empty());
   TemplateURL* modifiable_url = const_cast<TemplateURL*>(template_url);
   modifiable_url->data_.short_name = short_name;
   modifiable_url->data_.SetKeyword(keyword);
   modifiable_url->SetURL(url);
   Add(modifiable_url);
@@ skipping 49 matching lines @@
   }
 
   if (!GetTemplateURLForExtension(extension)) {
     TemplateURLData data;
     data.short_name = UTF8ToUTF16(extension->name());
     data.SetKeyword(UTF8ToUTF16(extension->omnibox_keyword()));
     // This URL is not actually used for navigation. It holds the extension's
     // ID, as well as forcing the TemplateURL to be treated as a search keyword.
     data.SetURL(std::string(chrome::kExtensionScheme) + "://" +
         extension->id() + "/?q={searchTerms}");
-    Add(new TemplateURL(data));
+    Add(new TemplateURL(profile_, data));
   }
 }
 
 void TemplateURLService::UnregisterExtensionKeyword(
     const Extension* extension) {
   if (loaded_) {
     const TemplateURL* url = GetTemplateURLForExtension(extension);
     if (url)
       Remove(url);
   } else {
@@ skipping 40 matching lines @@
   TemplateURLData data(url->data());
   data.short_name = title;
   data.SetKeyword(keyword);
   if (search_url != data.url()) {
     data.SetURL(search_url);
     // The urls have changed, reset the favicon url.
     data.favicon_url = GURL();
   }
   data.safe_for_autoreplace = false;
   data.last_modified = time_provider_();
-  TemplateURL new_url(data);
+  TemplateURL new_url(const_cast<TemplateURL*>(url)->profile(), data);
   UpdateNoNotify(url, new_url);
   NotifyObservers();
 }
 
 bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
   return url != GetDefaultSearchProvider() &&
       url->url_ref().SupportsReplacement() && !is_default_search_managed();
 }
 
 void TemplateURLService::SetDefaultSearchProvider(const TemplateURL* url) {
@@ skipping 11 matching lines @@
   if (loaded_ && !load_failed_)
     return default_search_provider_;
 
   // We're not loaded, rely on the default search provider stored in prefs.
   return initial_default_search_provider_.get();
 }
 
 const TemplateURL* TemplateURLService::FindNewDefaultSearchProvider() {
   // See if the prepopulated default still exists.
   scoped_ptr<TemplateURL> prepopulated_default(
-      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(GetPrefs()));
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(profile_));
   for (TemplateURLVector::iterator i = template_urls_.begin();
        i != template_urls_.end(); ++i) {
     if ((*i)->prepopulate_id() == prepopulated_default->prepopulate_id())
       return *i;
   }
   // If not, use the first non-extension keyword of the templates.
   for (TemplateURLVector::const_iterator i(template_urls_.begin());
        i != template_urls_.end(); ++i) {
     if (!(*i)->IsExtensionKeyword())
       return *i;
@@ skipping 41 matching lines @@
   }
 
   // initial_default_search_provider_ is only needed before we've finished
   // loading. Now that we've loaded we can nuke it.
   initial_default_search_provider_.reset();
   is_default_search_managed_ = false;
 
   std::vector<TemplateURL*> template_urls;
   const TemplateURL* default_search_provider = NULL;
   int new_resource_keyword_version = 0;
-  GetSearchProvidersUsingKeywordResult(*result, service_.get(), GetPrefs(),
+  GetSearchProvidersUsingKeywordResult(*result, service_.get(), profile_,
       &template_urls, &default_search_provider, &new_resource_keyword_version);
 
   bool database_specified_a_default = (default_search_provider != NULL);
 
   // Check if default search provider is now managed.
   scoped_ptr<TemplateURL> default_from_prefs;
   LoadDefaultSearchProviderFromPrefs(&default_from_prefs,
                                      &is_default_search_managed_);
 
   // Check if the default search provider has been changed in Web Data by
   // another program. No immediate action is performed because the default
   // search may be changed below by Sync which effectively undoes the hijacking.
   bool is_default_search_hijacked = false;
   const TemplateURL* hijacked_default_search_provider = NULL;
   scoped_ptr<TemplateURL> backup_default_search_provider;
   // No check is required if the default search is managed.
   // |DidDefaultSearchProviderChange| must always be called because it will
   // take care of the unowned backup default search provider instance.
-  if (DidDefaultSearchProviderChange(*result,
+  if (DidDefaultSearchProviderChange(*result, profile_,
                                      &backup_default_search_provider) &&
       !is_default_search_managed_) {
     hijacked_default_search_provider = default_search_provider;
     is_default_search_hijacked = true;
   }
 
   // Remove entries that were created because of policy as they may have
   // changed since the database was saved.
   RemoveProvidersCreatedByPolicy(&template_urls,
                                  &default_search_provider,
                                  default_from_prefs.get());
 
   PatchMissingSyncGUIDs(&template_urls);
 
   if (is_default_search_managed_) {
     SetTemplateURLs(template_urls);
 
     if (TemplateURLsHaveSamePrefs(default_search_provider,
                                   default_from_prefs.get())) {
       // The value from the preferences was previously stored in the database.
       // Reuse it.
     } else {
       // The value from the preferences takes over.
       default_search_provider = NULL;
       if (default_from_prefs.get()) {
         TemplateURLData data(default_from_prefs->data());
         data.created_by_policy = true;
         data.id = kInvalidTemplateURLID;
-        TemplateURL* managed_default = new TemplateURL(data);
+        TemplateURL* managed_default = new TemplateURL(profile_, data);
         AddNoNotify(managed_default, true);
         default_search_provider = managed_default;
       }
     }
     // Note that this saves the default search provider to prefs.
     if (!default_search_provider ||
         !default_search_provider->IsExtensionKeyword())
       SetDefaultSearchProviderNoNotify(default_search_provider);
   } else {
     // If we had a managed default, replace it with the synced default if
     // applicable, or the first provider of the list.
     const TemplateURL* synced_default = GetPendingSyncedDefaultSearchProvider();
     if (synced_default) {
       default_search_provider = synced_default;
       pending_synced_default_search_ = false;
     } else if (database_specified_a_default &&
                default_search_provider == NULL) {
       for (std::vector<TemplateURL*>::const_iterator i = template_urls.begin();
            i != template_urls.end(); ++i) {
-        if (!(*i)->IsExtensionKeyword()) {
+        if (!(*i)->IsExtensionKeyword() && (*i)->SupportsReplacement()) {
           default_search_provider = *i;
           break;
         }
       }
     }
 
     // If the default search provider existed previously, then just
     // set the member variable. Otherwise, we'll set it using the method
     // to ensure that it is saved properly after its id is set.
     if (default_search_provider &&
@@ skipping 153 matching lines @@
   SyncChangeList new_changes;
   SyncError error;
   for (SyncChangeList::const_iterator iter = change_list.begin();
       iter != change_list.end(); ++iter) {
     DCHECK_EQ(syncable::SEARCH_ENGINES, iter->sync_data().GetDataType());
 
     std::string guid =
         iter->sync_data().GetSpecifics().search_engine().sync_guid();
     const TemplateURL* existing_turl = GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> turl(CreateTemplateURLFromTemplateURLAndSyncData(
-        existing_turl, iter->sync_data(), &new_changes));
+        profile_, existing_turl, iter->sync_data(), &new_changes));
     if (!turl.get())
       continue;
 
     const TemplateURL* existing_keyword_turl =
         GetTemplateURLForKeyword(turl->keyword());
 
     if (iter->change_type() == SyncChange::ACTION_DELETE && existing_turl) {
       bool delete_default = (existing_turl == GetDefaultSearchProvider());
 
       if (delete_default && is_default_search_managed_) {
         NOTREACHED() << "Tried to delete managed default search provider";
       } else {
         if (delete_default)
           default_search_provider_ = NULL;
 
         Remove(existing_turl);
 
         if (delete_default)
           SetDefaultSearchProvider(FindNewDefaultSearchProvider());
       }
     } else if (iter->change_type() == SyncChange::ACTION_ADD &&
                !existing_turl) {
       std::string guid = turl->sync_guid();
       if (existing_keyword_turl)
         ResolveSyncKeywordConflict(turl.get(), &new_changes);
       // Force the local ID to kInvalidTemplateURLID so we can add it.
       TemplateURLData data(turl->data());
       data.id = kInvalidTemplateURLID;
-      Add(new TemplateURL(data));
+      Add(new TemplateURL(profile_, data));
 
       // Possibly set the newly added |turl| as the default search provider.
       SetDefaultSearchProviderIfNewlySynced(guid);
     } else if (iter->change_type() == SyncChange::ACTION_UPDATE &&
                existing_turl) {
       // Possibly resolve a keyword conflict if they have the same keywords but
       // are not the same entry.
       if (existing_keyword_turl && existing_keyword_turl != existing_turl)
         ResolveSyncKeywordConflict(turl.get(), &new_changes);
       UpdateNoNotify(existing_turl, *turl);
@@ skipping 50 matching lines @@
 
   // Build maps of our sync GUIDs to SyncData.
   SyncDataMap local_data_map = CreateGUIDToSyncDataMap(
       GetAllSyncData(syncable::SEARCH_ENGINES));
   SyncDataMap sync_data_map = CreateGUIDToSyncDataMap(initial_sync_data);
 
   for (SyncDataMap::const_iterator iter = sync_data_map.begin();
       iter != sync_data_map.end(); ++iter) {
     const TemplateURL* local_turl = GetTemplateURLForGUID(iter->first);
     scoped_ptr<TemplateURL> sync_turl(
-        CreateTemplateURLFromTemplateURLAndSyncData(local_turl, iter->second,
-                                                    &new_changes));
+        CreateTemplateURLFromTemplateURLAndSyncData(profile_, local_turl,
+            iter->second, &new_changes));
     if (!sync_turl.get())
       continue;
 
     if (local_turl) {
       // This local search engine is already synced. If the timestamp differs
       // from Sync, we need to update locally or to the cloud. Note that if the
       // timestamps are equal, we touch neither.
       if (sync_turl->last_modified() > local_turl->last_modified()) {
         // We've received an update from Sync. We should replace all synced
         // fields in the local TemplateURL. Note that this includes the
@@ skipping 24 matching lines @@
       } else {
         std::string guid = sync_turl->sync_guid();
         // Keyword conflict is possible in this case. Resolve it first before
         // adding the new TemplateURL. Note that we don't remove the local TURL
         // from local_data_map in this case as it may still need to be pushed to
         // the cloud.
         ResolveSyncKeywordConflict(sync_turl.get(), &new_changes);
         // Force the local ID to kInvalidTemplateURLID so we can add it.
         TemplateURLData data(sync_turl->data());
         data.id = kInvalidTemplateURLID;
-        Add(new TemplateURL(data));
+        Add(new TemplateURL(profile_, data));
 
         // Possibly set the newly added |turl| as the default search provider.
         SetDefaultSearchProviderIfNewlySynced(guid);
       }
     }
   }
 
   // The remaining SyncData in local_data_map should be everything that needs to
   // be pushed as ADDs to sync.
   for (SyncDataMap::const_iterator iter = local_data_map.begin();
@@ skipping 66 matching lines @@
   se_specifics->set_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(turl.sync_guid());
   return SyncData::CreateLocalData(se_specifics->sync_guid(),
                                    se_specifics->keyword(),
                                    specifics);
 }
 
 // static
 TemplateURL* TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
+    Profile* profile,
     const TemplateURL* existing_turl,
     const SyncData& sync_data,
     SyncChangeList* change_list) {
+  DCHECK(change_list);
+
   sync_pb::SearchEngineSpecifics specifics =
       sync_data.GetSpecifics().search_engine();
 
   // Past bugs might have caused either of these fields to be empty.  Just
   // delete this data off the server.
   if (specifics.url().empty() || specifics.sync_guid().empty()) {
     change_list->push_back(SyncChange(SyncChange::ACTION_DELETE, sync_data));
     return NULL;
   }
 
@@ skipping 12 matching lines @@
   data.date_created = base::Time::FromInternalValue(specifics.date_created());
   data.last_modified = base::Time::FromInternalValue(specifics.last_modified());
   data.prepopulate_id = specifics.prepopulate_id();
   data.sync_guid = specifics.sync_guid();
   if (existing_turl) {
     data.id = existing_turl->id();
     data.created_by_policy = existing_turl->created_by_policy();
     data.usage_count = existing_turl->usage_count();
   }
 
-  TemplateURL* turl = new TemplateURL(data);
+  TemplateURL* turl = new TemplateURL(profile, data);
   DCHECK(!turl->IsExtensionKeyword());
   return turl;
 }
 
 // static
 SyncDataMap TemplateURLService::CreateGUIDToSyncDataMap(
     const SyncDataList& sync_data) {
   SyncDataMap data_map;
   for (SyncDataList::const_iterator i(sync_data.begin()); i != sync_data.end();
        ++i)
@@ skipping 47 matching lines @@
       std::string osd_url(initializers[i].url);
       osd_url.replace(template_position, arraysize(kTemplateParameter) - 1,
                       kSearchTermParameter);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
       TemplateURLData data;
       data.short_name = UTF8ToUTF16(initializers[i].content);
       data.SetKeyword(UTF8ToUTF16(initializers[i].keyword));
       data.SetURL(osd_url);
-      AddNoNotify(new TemplateURL(data), true);
+      AddNoNotify(new TemplateURL(profile_, data), true);
     }
   }
 
   // Initialize default search.
   UpdateDefaultSearch();
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine, not in headless mode and not in Chrome Frame.
   if (initial_default_search_provider_.get() &&
       initial_default_search_provider_->url_ref().HasGoogleBaseURLs()) {
@@ skipping 196 matching lines @@
   if (!id_string.empty() && !*is_managed) {
     int64 value;
     base::StringToInt64(id_string, &value);
     data.id = value;
   }
   if (!prepopulate_id.empty() && !*is_managed) {
     int value;
     base::StringToInt(prepopulate_id, &value);
     data.prepopulate_id = value;
   }
-  default_provider->reset(new TemplateURL(data));
+  default_provider->reset(new TemplateURL(profile_, data));
   DCHECK(!(*default_provider)->IsExtensionKeyword());
   return true;
 }
 
 bool TemplateURLService::CanReplaceKeywordForHost(
     const std::string& host,
     const TemplateURL** to_replace) {
   DCHECK(!to_replace || !*to_replace);
   const TemplateURLSet* urls = provider_map_.GetURLsForHost(host);
   if (!urls)
@@ skipping 202 matching lines @@
 
 void TemplateURLService::UpdateDefaultSearch() {
   if (!loaded_) {
     // Set |initial_default_search_provider_| from the preferences.  We use this
     // value for default search provider until the database has been loaded.
     if (!LoadDefaultSearchProviderFromPrefs(&initial_default_search_provider_,
                                             &is_default_search_managed_)) {
       // Prefs does not specify, so rely on the prepopulated engines.  This
       // should happen only the first time Chrome is started.
       initial_default_search_provider_.reset(
-          TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(GetPrefs()));
+          TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(profile_));
       is_default_search_managed_ = false;
     }
     return;
   }
   // Load the default search specified in prefs.
   scoped_ptr<TemplateURL> new_default_from_prefs;
   bool new_is_default_managed = false;
   // Load the default from prefs.  It's possible that it won't succeed
   // because we are in the middle of doing SaveDefaultSearchProviderToPrefs()
   // and all the preference items have not been saved.  In that case, we
@@ skipping 16 matching lines @@
     if (new_default_from_prefs.get() == NULL) {
       // default_search_provider_ can't be NULL otherwise
       // TemplateURLsHaveSamePrefs would have returned true.  Remove this now
       // invalid value.
       const TemplateURL* old_default = default_search_provider_;
       SetDefaultSearchProviderNoNotify(NULL);
       RemoveNoNotify(old_default);
     } else if (default_search_provider_) {
       TemplateURLData data(new_default_from_prefs->data());
       data.created_by_policy = true;
-      TemplateURL new_values(data);
+      TemplateURL new_values(profile_, data);
       UpdateNoNotify(default_search_provider_, new_values);
     } else {
       TemplateURL* new_template = NULL;
       if (new_default_from_prefs.get()) {
         TemplateURLData data(new_default_from_prefs->data());
         data.created_by_policy = true;
-        new_template = new TemplateURL(data);
+        new_template = new TemplateURL(profile_, data);
         AddNoNotify(new_template, true);
       }
       SetDefaultSearchProviderNoNotify(new_template);
     }
   } else if (!is_default_search_managed_ && new_is_default_managed) {
     // The default used to be unmanaged and is now managed.  Add the new
     // managed default to the list of URLs and set it as default.
     is_default_search_managed_ = new_is_default_managed;
     TemplateURL* new_template = NULL;
     if (new_default_from_prefs.get()) {
       TemplateURLData data(new_default_from_prefs->data());
       data.created_by_policy = true;
-      new_template = new TemplateURL(data);
+      new_template = new TemplateURL(profile_, data);
       AddNoNotify(new_template, true);
     }
     SetDefaultSearchProviderNoNotify(new_template);
   } else {
     // The default was managed and is no longer.
     DCHECK(is_default_search_managed_ && !new_is_default_managed);
     is_default_search_managed_ = new_is_default_managed;
     // If we had a default, delete the previous default if created by policy
     // and set a likely default.
     if ((default_search_provider_ != NULL) &&
@@ skipping 189 matching lines @@
     }
   }
 }
 
 void TemplateURLService::ResetTemplateURLGUID(const TemplateURL* url,
                                               const std::string& guid) {
   DCHECK(!guid.empty());
 
   TemplateURLData data(url->data());
   data.sync_guid = guid;
-  TemplateURL new_url(data);
+  TemplateURL new_url(const_cast<TemplateURL*>(url)->profile(), data);
   UpdateNoNotify(url, new_url);
 }
 
 string16 TemplateURLService::UniquifyKeyword(const TemplateURL& turl) const {
   // Already unique.
   if (!GetTemplateURLForKeyword(turl.keyword()))
     return turl.keyword();
 
   // First, try to return the generated keyword for the TemplateURL.
   GURL gurl(turl.url());
@@ skipping 33 matching lines @@
     DCHECK(!GetTemplateURLForKeyword(new_keyword));
     sync_turl->data_.SetKeyword(new_keyword);
     // If we update the cloud TURL, we need to push an update back to sync
     // informing it that something has changed.
     SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
     change_list->push_back(SyncChange(SyncChange::ACTION_UPDATE, sync_data));
   } else {
     string16 new_keyword = UniquifyKeyword(*existing_turl);
     TemplateURLData data(existing_turl->data());
     data.SetKeyword(new_keyword);
-    TemplateURL new_turl(data);
+    TemplateURL new_turl(const_cast<TemplateURL*>(existing_turl)->profile(),
+                         data);
     UpdateNoNotify(existing_turl, new_turl);
     NotifyObservers();
   }
   return true;
 }
 
 const TemplateURL* TemplateURLService::FindDuplicateOfSyncTemplateURL(
     const TemplateURL& sync_turl) {
   const TemplateURL* existing_turl =
       GetTemplateURLForKeyword(sync_turl.keyword());
@@ skipping 76 matching lines @@
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (template_url->sync_guid().empty() &&
         !template_url->IsExtensionKeyword()) {
       template_url->data_.sync_guid = guid::GenerateGUID();
       if (service_.get())
         service_->UpdateKeyword(*template_url);
     }
   }
 }