Remove Profile* from TemplateURL

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 <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 409 matching lines @@
 
   // Remove leading "www.".
   result = net::StripWWW(result);
 
   // Remove trailing "/".
   return (result.length() > 0 && result[result.length() - 1] == '/') ?
       result.substr(0, result.length() - 1) : result;
 }
 
 // static
-GURL TemplateURLService::GenerateSearchURL(TemplateURL* t_url) {
-  DCHECK(t_url);
-  UIThreadSearchTermsData search_terms_data(t_url->profile());
-  return GenerateSearchURLUsingTermsData(t_url, search_terms_data);
-}
-
-// static
-GURL TemplateURLService::GenerateSearchURLUsingTermsData(
+GURL TemplateURLService::GenerateSearchURL(
     const TemplateURL* t_url,
     const SearchTermsData& search_terms_data) {
   DCHECK(t_url);
 
   const TemplateURLRef& search_ref = t_url->url_ref();
   if (!search_ref.IsValid(search_terms_data))
     return GURL();
 
   if (!search_ref.SupportsReplacement(search_terms_data))
     return GURL(t_url->url());
@@ skipping 158 matching lines @@
   if (elem != guid_to_template_map_.end())
     return elem->second;
   return (!loaded_ &&
       initial_default_search_provider_.get() &&
       (initial_default_search_provider_->sync_guid() == sync_guid)) ?
       initial_default_search_provider_.get() : NULL;
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForHost(
     const std::string& host) {
-  if (loaded_) {
-    TemplateURL* t_url = provider_map_->GetTemplateURLForHost(host);
-    if (t_url)
-      return t_url;
-  }
-  return (!loaded_ &&
-      initial_default_search_provider_.get() &&
-      (GenerateSearchURL(initial_default_search_provider_.get()).host() ==
-          host)) ? initial_default_search_provider_.get() : NULL;
+  if (loaded_)
+    return provider_map_->GetTemplateURLForHost(host);
+  TemplateURL* initial_dsp = initial_default_search_provider_.get();
+  if (!initial_dsp)
+    return NULL;
+  return (GenerateSearchURL(initial_dsp, search_terms_data()).host() == host) ?
+      initial_dsp : NULL;
 }
 
 bool TemplateURLService::Add(TemplateURL* template_url) {
   WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
   if (!AddNoNotify(template_url, true))
     return false;
   NotifyObservers();
   return true;
 }
 
-void TemplateURLService::AddAndSetProfile(TemplateURL* template_url,
-                                          Profile* profile) {
-  template_url->profile_ = profile;
-  Add(template_url);
-}
-
 void TemplateURLService::AddWithOverrides(TemplateURL* template_url,
                                           const base::string16& short_name,
                                           const base::string16& keyword,
                                           const std::string& url) {
   DCHECK(!keyword.empty());
   DCHECK(!url.empty());
   template_url->data_.short_name = short_name;
   template_url->data_.SetKeyword(keyword);
   template_url->SetURL(url);
   Add(template_url);
@@ skipping 58 matching lines @@
     base::Time created_before) {
   GURL o(origin.GetOrigin());
   bool should_notify = false;
   WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
   for (size_t i = 0; i < template_urls_.size();) {
     if (template_urls_[i]->date_created() >= created_after &&
         (created_before.is_null() ||
          template_urls_[i]->date_created() < created_before) &&
         CanReplace(template_urls_[i]) &&
         (o.is_empty() ||
-         GenerateSearchURL(template_urls_[i]).GetOrigin() == o)) {
+         GenerateSearchURL(template_urls_[i],
+                           search_terms_data()).GetOrigin() == o)) {
       RemoveNoNotify(template_urls_[i]);
       should_notify = true;
     } else {
       ++i;
     }
   }
   if (should_notify)
     NotifyObservers();
 }
 
@@ skipping 121 matching lines @@
 
   // Remove items.
   for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
        i < actions.removed_engines.end(); ++i)
     RemoveNoNotify(*i);
 
   // Edit items.
   for (EditedEngines::iterator i(actions.edited_engines.begin());
        i < actions.edited_engines.end(); ++i) {
     UIThreadSearchTermsData search_terms_data(profile());
-    TemplateURL new_values(profile(), i->second);
+    TemplateURL new_values(i->second);
     UpdateNoNotify(i->first, new_values, search_terms_data);
   }
 
   // Add items.
   for (std::vector<TemplateURLData>::const_iterator i =
            actions.added_engines.begin();
        i < actions.added_engines.end();
        ++i) {
-    AddNoNotify(new TemplateURL(profile_, *i), true);
+    AddNoNotify(new TemplateURL(*i), true);
   }
 
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(
       &dsp_change_origin_, DSP_CHANGE_PROFILE_RESET);
 
   default_search_manager_.ClearUserSelectedDefaultSearchEngine();
 
   if (!default_search_provider_) {
     // If the default search provider came from a user pref we would have been
     // notified of the new (fallback-provided) value in
@@ skipping 216 matching lines @@
         // not ideal, but it prevents a far more severe bug where the default is
         // unexpectedly swapped to something else. The user can safely delete
         // the extra entry again later, if they choose. Most users who do not
         // look at the search engines UI will not notice this.
         // Note that we append a special character to the end of the keyword in
         // an attempt to avoid a ping-poinging situation where receiving clients
         // may try to continually delete the resurrected entry.
         base::string16 updated_keyword = UniquifyKeyword(*existing_turl, true);
         TemplateURLData data(existing_turl->data());
         data.SetKeyword(updated_keyword);
-        TemplateURL new_turl(existing_turl->profile(), data);
-        UIThreadSearchTermsData search_terms_data(existing_turl->profile());
-        if (UpdateNoNotify(existing_turl, new_turl, search_terms_data))
+        TemplateURL new_turl(data);
+        if (UpdateNoNotify(existing_turl, new_turl, search_terms_data()))
           NotifyObservers();
 
         syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(new_turl);
         new_changes.push_back(syncer::SyncChange(FROM_HERE,
                                                  syncer::SyncChange::ACTION_ADD,
                                                  sync_data));
         // Ignore the delete attempt. This means we never end up resetting the
         // default search provider due to an ACTION_DELETE from sync.
         continue;
       }
@@ skipping 10 matching lines @@
       if (existing_keyword_turl) {
         // Resolve any conflicts so we can safely add the new entry.
         ResolveSyncKeywordConflict(turl.get(), existing_keyword_turl,
                                    &new_changes);
       }
       base::AutoReset<DefaultSearchChangeOrigin> change_origin(
           &dsp_change_origin_, DSP_CHANGE_SYNC_ADD);
       // Force the local ID to kInvalidTemplateURLID so we can add it.
       TemplateURLData data(turl->data());
       data.id = kInvalidTemplateURLID;
-      TemplateURL* added = new TemplateURL(profile_, data);
+      TemplateURL* added = new TemplateURL(data);
       if (Add(added))
         MaybeUpdateDSEAfterSync(added);
     } else if (iter->change_type() == syncer::SyncChange::ACTION_UPDATE) {
       if (!existing_turl) {
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_UPDATE");
         continue;
       }
       if (existing_keyword_turl && (existing_keyword_turl != existing_turl)) {
         // Resolve any conflicts with other entries so we can safely update the
         // keyword.
         ResolveSyncKeywordConflict(turl.get(), existing_keyword_turl,
                                    &new_changes);
       }
-      UIThreadSearchTermsData search_terms_data(existing_turl->profile());
-      if (UpdateNoNotify(existing_turl, *turl, search_terms_data)) {
+      if (UpdateNoNotify(existing_turl, *turl, search_terms_data())) {
         NotifyObservers();
         MaybeUpdateDSEAfterSync(existing_turl);
       }
     } else {
       // We've unexpectedly received an ACTION_INVALID.
       error = sync_error_factory_->CreateAndUploadError(
           FROM_HERE,
           "ProcessSyncChanges received an ACTION_INVALID");
     }
   }
@@ skipping 78 matching lines @@
       DCHECK(IsFromSync(local_turl, sync_data_map));
       // 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
         // TemplateURLID and the TemplateURL may have to be reparsed. This
         // also makes the local data's last_modified timestamp equal to Sync's,
         // avoiding an Update on the next MergeData call.
-        UIThreadSearchTermsData search_terms_data(local_turl->profile());
-        if (UpdateNoNotify(local_turl, *sync_turl, search_terms_data))
+        if (UpdateNoNotify(local_turl, *sync_turl, search_terms_data()))
           NotifyObservers();
         merge_result.set_num_items_modified(
             merge_result.num_items_modified() + 1);
       } else if (sync_turl->last_modified() < local_turl->last_modified()) {
         // Otherwise, we know we have newer data, so update Sync with our
         // data fields.
         new_changes.push_back(
             syncer::SyncChange(FROM_HERE,
                                syncer::SyncChange::ACTION_UPDATE,
                                local_data_map[local_turl->sync_guid()]));
@@ skipping 178 matching lines @@
   bool deduped = DeDupeEncodings(&data.input_encodings);
   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();
   data.alternate_urls.clear();
   for (int i = 0; i < specifics.alternate_urls_size(); ++i)
     data.alternate_urls.push_back(specifics.alternate_urls(i));
   data.search_terms_replacement_key = specifics.search_terms_replacement_key();
 
-  TemplateURL* turl = new TemplateURL(profile, data);
+  TemplateURL* turl = new TemplateURL(data);
   UIThreadSearchTermsData search_terms_data(profile);
   // If this TemplateURL matches a built-in prepopulated template URL, it's
   // possible that sync is trying to modify fields that should not be touched.
   // Revert these fields to the built-in values.
   UpdateTemplateURLIfPrepopulated(turl, profile);
   DCHECK_NE(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, turl->GetType());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(search_terms_data, true);
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
@@ skipping 87 matching lines @@
       DCHECK(initializers[i].keyword);
       DCHECK(initializers[i].url);
       DCHECK(initializers[i].content);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
       TemplateURLData data;
       data.short_name = base::UTF8ToUTF16(initializers[i].content);
       data.SetKeyword(base::UTF8ToUTF16(initializers[i].keyword));
       data.SetURL(initializers[i].url);
-      TemplateURL* template_url = new TemplateURL(profile_, data);
+      TemplateURL* template_url = new TemplateURL(data);
       AddNoNotify(template_url, true);
 
       // Set the first provided identifier to be the default.
       if (i == 0)
         default_search_manager_.SetUserSelectedDefaultSearchEngine(data);
     }
   }
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine and not in headless mode.
@@ skipping 36 matching lines @@
     if (best_fallback)
       keyword_to_template_map_[keyword] = best_fallback;
     else
       keyword_to_template_map_.erase(keyword);
   }
 
   if (!template_url->sync_guid().empty())
     guid_to_template_map_.erase(template_url->sync_guid());
   // |provider_map_| is only initialized after loading has completed.
   if (loaded_) {
-    UIThreadSearchTermsData search_terms_data(template_url->profile());
-    provider_map_->Remove(template_url, search_terms_data);
+    provider_map_->Remove(template_url, search_terms_data());
   }
 }
 
 void TemplateURLService::AddToMaps(TemplateURL* template_url) {
   bool template_url_is_omnibox_api =
       template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION;
   const base::string16& keyword = template_url->keyword();
   KeywordToTemplateMap::const_iterator i =
       keyword_to_template_map_.find(keyword);
   if (i == keyword_to_template_map_.end()) {
@@ skipping 189 matching lines @@
     return;
 
   size_t default_search_index;
   ScopedVector<TemplateURLData> prepopulated_urls =
       TemplateURLPrepopulateData::GetPrepopulatedEngines(
           profile ? profile->GetPrefs() : NULL, &default_search_index);
 
   for (size_t i = 0; i < prepopulated_urls.size(); ++i) {
     if (prepopulated_urls[i]->prepopulate_id == prepopulate_id) {
       MergeIntoPrepopulatedEngineData(template_url, prepopulated_urls[i]);
-      template_url->CopyFrom(TemplateURL(profile, *prepopulated_urls[i]));
+      template_url->CopyFrom(TemplateURL(*prepopulated_urls[i]));
     }
   }
 }
 
 void TemplateURLService::MaybeUpdateDSEAfterSync(TemplateURL* synced_turl) {
   if (GetPrefs() &&
       (synced_turl->sync_guid() ==
           GetPrefs()->GetString(prefs::kSyncedDefaultSearchProviderGUID))) {
     default_search_manager_.SetUserSelectedDefaultSearchEngine(
         synced_turl->data());
@@ skipping 62 matching lines @@
                    history::SOURCE_BROWSED, false);
 }
 
 void TemplateURLService::GoogleBaseURLChanged(const GURL& old_base_url) {
   WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
   bool something_changed = false;
   for (TemplateURLVector::iterator i(template_urls_.begin());
        i != template_urls_.end(); ++i) {
     TemplateURL* t_url = *i;
     if (t_url->HasGoogleBaseURLs(search_terms_data())) {
-      TemplateURL updated_turl(t_url->profile(), t_url->data());
+      TemplateURL updated_turl(t_url->data());
       updated_turl.ResetKeywordIfNecessary(search_terms_data(), false);
       KeywordToTemplateMap::const_iterator existing_entry =
           keyword_to_template_map_.find(updated_turl.keyword());
       if ((existing_entry != keyword_to_template_map_.end()) &&
           (existing_entry->second != t_url)) {
         // The new autogenerated keyword conflicts with another TemplateURL.
         // Overwrite it if it's replaceable; otherwise, leave |t_url| using its
         // current keyword.  (This will not prevent |t_url| from auto-updating
         // the keyword in the future if the conflicting TemplateURL disappears.)
         // Note that we must still update |t_url| in this case, or the
         // |provider_map_| will not be updated correctly.
         if (CanReplace(existing_entry->second))
           RemoveNoNotify(existing_entry->second);
         else
           updated_turl.data_.SetKeyword(t_url->keyword());
       }
       something_changed = true;
       // This will send the keyword change to sync.  Note that other clients
       // need to reset the keyword to an appropriate local value when this
       // change arrives; see CreateTemplateURLFromTemplateURLAndSyncData().
       UpdateNoNotify(t_url, updated_turl,
-          OldBaseURLSearchTermsData(t_url->profile(), old_base_url.spec()));
+          OldBaseURLSearchTermsData(profile(), old_base_url.spec()));
     }
   }
   if (something_changed)
     NotifyObservers();
 }
 
 void TemplateURLService::OnGoogleURLUpdated(GURL old_url, GURL new_url) {
   if (loaded_)
     GoogleBaseURLChanged(old_url);
 }
@@ skipping 32 matching lines @@
     const TemplateURLData* data,
     DefaultSearchManager::Source source) {
   if (!loaded_) {
     // Set |initial_default_search_provider_| from the preferences. This is
     // mainly so we can hold ownership until we get to the point where the list
     // of keywords from Web Data is the owner of everything including the
     // default.
     bool changed = TemplateURL::MatchesData(
         initial_default_search_provider_.get(), data, search_terms_data());
     initial_default_search_provider_.reset(
-        data ? new TemplateURL(profile_, *data) : NULL);
+        data ? new TemplateURL(*data) : NULL);
     default_search_provider_source_ = source;
     return changed;
   }
 
   // Prevent recursion if we update the value stored in default_search_manager_.
   // Note that we exclude the case of data == NULL because that could cause a
   // false positive for recursion when the initial_default_search_provider_ is
   // NULL due to policy. We'll never actually get recursion with data == NULL.
   if (source == default_search_provider_source_ && data != NULL &&
       TemplateURL::MatchesData(default_search_provider_, data,
@@ skipping 23 matching lines @@
     default_search_provider_ =
         FindPrepopulatedTemplateURL(data->prepopulate_id);
     if (default_search_provider_) {
       TemplateURLData update_data(*data);
       update_data.sync_guid = default_search_provider_->sync_guid();
       if (!default_search_provider_->safe_for_autoreplace()) {
         update_data.safe_for_autoreplace = false;
         update_data.SetKeyword(default_search_provider_->keyword());
         update_data.short_name = default_search_provider_->short_name();
       }
-      UIThreadSearchTermsData search_terms_data(
-          default_search_provider_->profile());
       UpdateNoNotify(default_search_provider_,
-                     TemplateURL(profile_, update_data),
-                     search_terms_data);
+                     TemplateURL(update_data),
+                     search_terms_data());
     } else {
       // Normally the prepopulated fallback should be present in
       // |template_urls_|, but in a few cases it might not be:
       // (1) Tests that initialize the TemplateURLService in peculiar ways.
       // (2) If the user deleted the pre-populated default and we subsequently
       // lost their user-selected value.
-      TemplateURL* new_dse = new TemplateURL(profile_, *data);
+      TemplateURL* new_dse = new TemplateURL(*data);
       if (AddNoNotify(new_dse, true))
         default_search_provider_ = new_dse;
     }
   } else if (source == DefaultSearchManager::FROM_USER) {
     default_search_provider_ = GetTemplateURLForGUID(data->sync_guid);
     if (!default_search_provider_ && data->prepopulate_id) {
       default_search_provider_ =
           FindPrepopulatedTemplateURL(data->prepopulate_id);
     }
     TemplateURLData new_data(*data);
     new_data.show_in_default_list = true;
     if (default_search_provider_) {
-      UIThreadSearchTermsData search_terms_data(
-          default_search_provider_->profile());
       UpdateNoNotify(default_search_provider_,
-                     TemplateURL(profile_, new_data),
-                     search_terms_data);
+                     TemplateURL(new_data),
+                     search_terms_data());
     } else {
       new_data.id = kInvalidTemplateURLID;
-      TemplateURL* new_dse = new TemplateURL(profile_, new_data);
+      TemplateURL* new_dse = new TemplateURL(new_data);
       if (AddNoNotify(new_dse, true))
         default_search_provider_ = new_dse;
     }
     if (default_search_provider_ && GetPrefs()) {
       GetPrefs()->SetString(
           prefs::kSyncedDefaultSearchProviderGUID,
           default_search_provider_->sync_guid());
     }
 
   }
@@ skipping 130 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_();
-  UIThreadSearchTermsData search_terms_data(url->profile());
-  return UpdateNoNotify(url, TemplateURL(profile_, data), search_terms_data);
+  return UpdateNoNotify(url, TemplateURL(data), search_terms_data());
 }
 
 void TemplateURLService::NotifyObservers() {
   if (!loaded_)
     return;
 
   FOR_EACH_OBSERVER(TemplateURLServiceObserver, model_observers_,
                     OnTemplateURLServiceChanged());
 }
 
@@ skipping 37 matching lines @@
     }
   }
 
   if (default_from_prefs) {
     default_search_provider_ = NULL;
     default_search_provider_source_ = DefaultSearchManager::FROM_POLICY;
     TemplateURLData new_data(*default_from_prefs);
     if (new_data.sync_guid.empty())
       new_data.sync_guid = base::GenerateGUID();
     new_data.created_by_policy = true;
-    TemplateURL* new_dse = new TemplateURL(profile_, new_data);
+    TemplateURL* new_dse = new TemplateURL(new_data);
     if (AddNoNotify(new_dse, true))
       default_search_provider_ = new_dse;
   }
 }
 
 void TemplateURLService::ResetTemplateURLGUID(TemplateURL* url,
                                               const std::string& guid) {
   DCHECK(loaded_);
   DCHECK(!guid.empty());
 
   TemplateURLData data(url->data());
   data.sync_guid = guid;
-  UIThreadSearchTermsData search_terms_data(url->profile());
-  UpdateNoNotify(url, TemplateURL(profile_, data), search_terms_data);
+  UpdateNoNotify(url, TemplateURL(data), search_terms_data());
 }
 
 base::string16 TemplateURLService::UniquifyKeyword(const TemplateURL& turl,
                                                    bool force) {
   if (!force) {
     // Already unique.
     if (!GetTemplateURLForKeyword(turl.keyword()))
       return turl.keyword();
 
     // First, try to return the generated keyword for the TemplateURL (except
@@ skipping 50 matching lines @@
   base::string16 new_keyword = UniquifyKeyword(*loser, false);
   DCHECK(!GetTemplateURLForKeyword(new_keyword));
   if (applied_turl_is_better) {
     // Just set the keyword of |unapplied_sync_turl|. The caller is responsible
     // for adding or updating unapplied_sync_turl in the local model.
     unapplied_sync_turl->data_.SetKeyword(new_keyword);
   } else {
     // Update |applied_sync_turl| in the local model with the new keyword.
     TemplateURLData data(applied_sync_turl->data());
     data.SetKeyword(new_keyword);
-    UIThreadSearchTermsData search_terms_data(applied_sync_turl->profile());
     if (UpdateNoNotify(
-            applied_sync_turl, TemplateURL(profile_, data), search_terms_data))
+            applied_sync_turl, TemplateURL(data), search_terms_data()))
       NotifyObservers();
   }
   // The losing TemplateURL should have their keyword updated. Send a change to
   // the server to reflect this change.
   syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*loser);
   change_list->push_back(syncer::SyncChange(FROM_HERE,
       syncer::SyncChange::ACTION_UPDATE,
       sync_data));
 }
 
@@ skipping 52 matching lines @@
       // This TemplateURL was either removed or overwritten in the local model.
       // Remove the entry from the local data so it isn't pushed up to Sync.
       local_data->erase(guid);
     }
   }
 
   if (should_add_sync_turl) {
     // Force the local ID to kInvalidTemplateURLID so we can add it.
     TemplateURLData data(sync_turl->data());
     data.id = kInvalidTemplateURLID;
-    TemplateURL* added = new TemplateURL(profile_, data);
+    TemplateURL* added = new TemplateURL(data);
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_SYNC_ADD);
     if (Add(added))
       MaybeUpdateDSEAfterSync(added);
     merge_result->set_num_items_added(
         merge_result->num_items_added() + 1);
   }
 }
 
 void TemplateURLService::PatchMissingSyncGUIDs(
@@ skipping 41 matching lines @@
 
 TemplateURL* TemplateURLService::CreateTemplateURLForExtension(
     const ExtensionKeyword& extension_keyword) {
   TemplateURLData data;
   data.short_name = base::UTF8ToUTF16(extension_keyword.extension_name);
   data.SetKeyword(base::UTF8ToUTF16(extension_keyword.extension_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(extensions::kExtensionScheme) + "://" +
       extension_keyword.extension_id + "/?q={searchTerms}");
-  return new TemplateURL(profile_, data);
+  return new TemplateURL(data);
 }
 
 TemplateURL* TemplateURLService::FindTemplateURLForExtension(
     const std::string& extension_id,
     TemplateURL::Type type) {
   DCHECK_NE(TemplateURL::NORMAL, type);
   for (TemplateURLVector::const_iterator i = template_urls_.begin();
        i != template_urls_.end(); ++i) {
     if ((*i)->GetType() == type &&
         (*i)->GetExtensionId() == extension_id)
@@ skipping 30 matching lines @@
 
   if (most_recently_intalled_default) {
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_OVERRIDE_SETTINGS_EXTENSION);
     default_search_manager_.SetExtensionControlledDefaultSearchEngine(
         most_recently_intalled_default->data());
   } else {
     default_search_manager_.ClearExtensionControlledDefaultSearchEngine();
   }
 }