1// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/search_engines/template_url_model.h"
6
7#include "base/command_line.h"
8#include "base/environment.h"
9#include "base/stl_util-inl.h"
10#include "base/string_number_conversions.h"
11#include "base/string_split.h"
12#include "base/utf_string_conversions.h"
13#include "chrome/browser/extensions/extension_service.h"
14#include "chrome/browser/google/google_url_tracker.h"
15#include "chrome/browser/history/history.h"
16#include "chrome/browser/history/history_notifications.h"
17#include "chrome/browser/net/url_fixer_upper.h"
18#include "chrome/browser/prefs/pref_service.h"
19#include "chrome/browser/prefs/pref_set_observer.h"
20#include "chrome/browser/profiles/profile.h"
21#include "chrome/browser/rlz/rlz.h"
22#include "chrome/browser/search_engines/search_host_to_urls_map.h"
23#include "chrome/browser/search_engines/search_terms_data.h"
24#include "chrome/browser/search_engines/template_url.h"
25#include "chrome/browser/search_engines/template_url_model_observer.h"
26#include "chrome/browser/search_engines/template_url_prepopulate_data.h"
27#include "chrome/browser/search_engines/util.h"
28#include "chrome/common/chrome_switches.h"
29#include "chrome/common/env_vars.h"
30#include "chrome/common/extensions/extension.h"
31#include "chrome/common/pref_names.h"
32#include "chrome/common/url_constants.h"
33#include "content/common/notification_service.h"
34#include "net/base/net_util.h"
35#include "ui/base/l10n/l10n_util.h"
36
37using base::Time;
38typedef SearchHostToURLsMap::TemplateURLSet TemplateURLSet;
39
40// String in the URL that is replaced by the search term.
41static const char kSearchTermParameter[] = "{searchTerms}";
42
43// String in Initializer that is replaced with kSearchTermParameter.
44static const char kTemplateParameter[] = "%s";
45
46// Term used when generating a search url. Use something obscure so that on
47// the rare case the term replaces the URL it's unlikely another keyword would
48// have the same url.
49static const char kReplacementTerm[] = "blah.blah.blah.blah.blah";
50
51
52// Removes from the vector any template URL that was created because of
53// policy.  These TemplateURLs are freed.
54// Sets default_search_provider to NULL if it was one of them.
55static void RemoveProvidersCreatedByPolicy(
56    std::vector<TemplateURL*>* template_urls,
57    const TemplateURL** default_search_provider) {
58  DCHECK(template_urls);
59  DCHECK(default_search_provider);
60  for (std::vector<TemplateURL*>::iterator i = template_urls->begin();
61      i != template_urls->end(); ) {
62    TemplateURL* template_url = *i;
63    if (template_url->created_by_policy()) {
64      if (*default_search_provider &&
65          (*default_search_provider)->id() == template_url->id())
66        *default_search_provider = NULL;
67      i = template_urls->erase(i);
68      delete template_url;
69    } else {
70      ++i;
71    }
72  }
73}
74
75class TemplateURLModel::LessWithPrefix {
76 public:
77  // We want to find the set of keywords that begin with a prefix.  The STL
78  // algorithms will return the set of elements that are "equal to" the
79  // prefix, where "equal(x, y)" means "!(cmp(x, y) || cmp(y, x))".  When
80  // cmp() is the typical std::less<>, this results in lexicographic equality;
81  // we need to extend this to mark a prefix as "not less than" a keyword it
82  // begins, which will cause the desired elements to be considered "equal to"
83  // the prefix.  Note: this is still a strict weak ordering, as required by
84  // equal_range() (though I will not prove that here).
85  //
86  // Unfortunately the calling convention is not "prefix and element" but
87  // rather "two elements", so we pass the prefix as a fake "element" which has
88  // a NULL KeywordDataElement pointer.
89  bool operator()(const KeywordToTemplateMap::value_type& elem1,
90                  const KeywordToTemplateMap::value_type& elem2) const {
91    return (elem1.second == NULL) ?
92        (elem2.first.compare(0, elem1.first.length(), elem1.first) > 0) :
93        (elem1.first < elem2.first);
94  }
95};
96
97TemplateURLModel::TemplateURLModel(Profile* profile)
98    : profile_(profile),
99      loaded_(false),
100      load_failed_(false),
101      load_handle_(0),
102      default_search_provider_(NULL),
103      is_default_search_managed_(false),
104      next_id_(1) {
105  DCHECK(profile_);
106  Init(NULL, 0);
107}
108
109TemplateURLModel::TemplateURLModel(const Initializer* initializers,
110                                   const int count)
111    : profile_(NULL),
112      loaded_(false),
113      load_failed_(false),
114      load_handle_(0),
115      service_(NULL),
116      default_search_provider_(NULL),
117      is_default_search_managed_(false),
118      next_id_(1) {
119  Init(initializers, count);
120}
121
122TemplateURLModel::~TemplateURLModel() {
123  if (load_handle_) {
124    DCHECK(service_.get());
125    service_->CancelRequest(load_handle_);
126  }
127
128  STLDeleteElements(&template_urls_);
129}
130
131// static
132string16 TemplateURLModel::GenerateKeyword(const GURL& url,
133                                           bool autodetected) {
134  // Don't autogenerate keywords for referrers that are the result of a form
135  // submission (TODO: right now we approximate this by checking for the URL
136  // having a query, but we should replace this with a call to WebCore to see if
137  // the originating page was actually a form submission), anything other than
138  // http, or referrers with a path.
139  //
140  // If we relax the path constraint, we need to be sure to sanitize the path
141  // elements and update AutocompletePopup to look for keywords using the path.
142  // See http://b/issue?id=863583.
143  if (!url.is_valid() ||
144      (autodetected && (url.has_query() || !url.SchemeIs(chrome::kHttpScheme) ||
145                        ((url.path() != "") && (url.path() != "/")))))
146    return string16();
147
148  // Strip "www." off the front of the keyword; otherwise the keyword won't work
149  // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
150  return net::StripWWW(UTF8ToUTF16(url.host()));
151}
152
153// static
154string16 TemplateURLModel::CleanUserInputKeyword(const string16& keyword) {
155  // Remove the scheme.
156  string16 result(l10n_util::ToLower(keyword));
157  url_parse::Component scheme_component;
158  if (url_parse::ExtractScheme(UTF16ToUTF8(keyword).c_str(),
159                               static_cast<int>(keyword.length()),
160                               &scheme_component)) {
161    // If the scheme isn't "http" or "https", bail.  The user isn't trying to
162    // type a web address, but rather an FTP, file:, or other scheme URL, or a
163    // search query with some sort of initial operator (e.g. "site:").
164    if (result.compare(0, scheme_component.end(),
165                       ASCIIToUTF16(chrome::kHttpScheme)) &&
166        result.compare(0, scheme_component.end(),
167                       ASCIIToUTF16(chrome::kHttpsScheme)))
168      return string16();
169
170    // Include trailing ':'.
171    result.erase(0, scheme_component.end() + 1);
172    // Many schemes usually have "//" after them, so strip it too.
173    const string16 after_scheme(ASCIIToUTF16("//"));
174    if (result.compare(0, after_scheme.length(), after_scheme) == 0)
175      result.erase(0, after_scheme.length());
176  }
177
178  // Remove leading "www.".
179  result = net::StripWWW(result);
180
181  // Remove trailing "/".
182  return (result.length() > 0 && result[result.length() - 1] == '/') ?
183      result.substr(0, result.length() - 1) : result;
184}
185
186// static
187GURL TemplateURLModel::GenerateSearchURL(const TemplateURL* t_url) {
188  DCHECK(t_url);
189  UIThreadSearchTermsData search_terms_data;
190  return GenerateSearchURLUsingTermsData(t_url, search_terms_data);
191}
192
193// static
194GURL TemplateURLModel::GenerateSearchURLUsingTermsData(
195    const TemplateURL* t_url,
196    const SearchTermsData& search_terms_data) {
197  DCHECK(t_url);
198  const TemplateURLRef* search_ref = t_url->url();
199  // Extension keywords don't have host-based search URLs.
200  if (!search_ref || !search_ref->IsValidUsingTermsData(search_terms_data) ||
201      t_url->IsExtensionKeyword())
202    return GURL();
203
204  if (!search_ref->SupportsReplacementUsingTermsData(search_terms_data))
205    return GURL(search_ref->url());
206
207  return GURL(search_ref->ReplaceSearchTermsUsingTermsData(
208      *t_url, ASCIIToUTF16(kReplacementTerm),
209      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
210      string16(), search_terms_data));
211}
212
213bool TemplateURLModel::CanReplaceKeyword(
214    const string16& keyword,
215    const GURL& url,
216    const TemplateURL** template_url_to_replace) {
217  DCHECK(!keyword.empty());  // This should only be called for non-empty
218                             // keywords. If we need to support empty kewords
219                             // the code needs to change slightly.
220  const TemplateURL* existing_url = GetTemplateURLForKeyword(keyword);
221  if (existing_url) {
222    // We already have a TemplateURL for this keyword. Only allow it to be
223    // replaced if the TemplateURL can be replaced.
224    if (template_url_to_replace)
225      *template_url_to_replace = existing_url;
226    return CanReplace(existing_url);
227  }
228
229  // We don't have a TemplateURL with keyword. Only allow a new one if there
230  // isn't a TemplateURL for the specified host, or there is one but it can
231  // be replaced. We do this to ensure that if the user assigns a different
232  // keyword to a generated TemplateURL, we won't regenerate another keyword for
233  // the same host.
234  if (url.is_valid() && !url.host().empty())
235    return CanReplaceKeywordForHost(url.host(), template_url_to_replace);
236  return true;
237}
238
239void TemplateURLModel::FindMatchingKeywords(
240    const string16& prefix,
241    bool support_replacement_only,
242    std::vector<string16>* matches) const {
243  // Sanity check args.
244  if (prefix.empty())
245    return;
246  DCHECK(matches != NULL);
247  DCHECK(matches->empty());  // The code for exact matches assumes this.
248
249  // Visual Studio 2010 has problems converting NULL to the null pointer for
250  // std::pair.  See http://connect.microsoft.com/VisualStudio/feedback/details/520043/error-converting-from-null-to-a-pointer-type-in-std-pair
251  // It will work if we pass nullptr.
252#if defined(_MSC_VER) && _MSC_VER >= 1600
253  const TemplateURL* null_url = nullptr;
254#else
255  const TemplateURL* null_url = NULL;
256#endif
257
258  // Find matching keyword range.  Searches the element map for keywords
259  // beginning with |prefix| and stores the endpoints of the resulting set in
260  // |match_range|.
261  const std::pair<KeywordToTemplateMap::const_iterator,
262                  KeywordToTemplateMap::const_iterator> match_range(
263      std::equal_range(
264          keyword_to_template_map_.begin(), keyword_to_template_map_.end(),
265          KeywordToTemplateMap::value_type(prefix, null_url),
266          LessWithPrefix()));
267
268  // Return vector of matching keywords.
269  for (KeywordToTemplateMap::const_iterator i(match_range.first);
270       i != match_range.second; ++i) {
271    DCHECK(i->second->url());
272    if (!support_replacement_only || i->second->url()->SupportsReplacement())
273      matches->push_back(i->first);
274  }
275}
276
277const TemplateURL* TemplateURLModel::GetTemplateURLForKeyword(
278                                     const string16& keyword) const {
279  KeywordToTemplateMap::const_iterator elem(
280      keyword_to_template_map_.find(keyword));
281  return (elem == keyword_to_template_map_.end()) ? NULL : elem->second;
282}
283
284const TemplateURL* TemplateURLModel::GetTemplateURLForHost(
285    const std::string& host) const {
286  return provider_map_.GetTemplateURLForHost(host);
287}
288
289void TemplateURLModel::Add(TemplateURL* template_url) {
290  AddNoNotify(template_url);
291  NotifyObservers();
292}
293
294void TemplateURLModel::Remove(const TemplateURL* template_url) {
295  RemoveNoNotify(template_url);
296  NotifyObservers();
297}
298
299void TemplateURLModel::RemoveAutoGeneratedBetween(Time created_after,
300                                                  Time created_before) {
301  bool should_notify = false;
302  for (size_t i = 0; i < template_urls_.size();) {
303    if (template_urls_[i]->date_created() >= created_after &&
304        (created_before.is_null() ||
305         template_urls_[i]->date_created() < created_before) &&
306        CanReplace(template_urls_[i])) {
307      RemoveNoNotify(template_urls_[i]);
308      should_notify = true;
309    } else {
310      ++i;
311    }
312  }
313  if (should_notify)
314    NotifyObservers();
315}
316
317void TemplateURLModel::RemoveAutoGeneratedSince(Time created_after) {
318  RemoveAutoGeneratedBetween(created_after, Time());
319}
320
321void TemplateURLModel::RegisterExtensionKeyword(const Extension* extension) {
322  // TODO(mpcomplete): disable the keyword when the extension is disabled.
323  if (extension->omnibox_keyword().empty())
324    return;
325
326  Load();
327  if (!loaded_) {
328    pending_extension_ids_.push_back(extension->id());
329    return;
330  }
331
332  const TemplateURL* existing_url = GetTemplateURLForExtension(extension);
333  string16 keyword = UTF8ToUTF16(extension->omnibox_keyword());
334
335  scoped_ptr<TemplateURL> template_url(new TemplateURL);
336  template_url->set_short_name(UTF8ToUTF16(extension->name()));
337  template_url->set_keyword(keyword);
338  // This URL is not actually used for navigation. It holds the extension's
339  // ID, as well as forcing the TemplateURL to be treated as a search keyword.
340  template_url->SetURL(
341      std::string(chrome::kExtensionScheme) + "://" +
342      extension->id() + "/?q={searchTerms}", 0, 0);
343  template_url->set_safe_for_autoreplace(false);
344
345  if (existing_url) {
346    // TODO(mpcomplete): only replace if the user hasn't changed the keyword.
347    // (We don't have UI for that yet).
348    UpdateNoNotify(existing_url, *template_url);
349  } else {
350    AddNoNotify(template_url.release());
351  }
352  NotifyObservers();
353}
354
355void TemplateURLModel::UnregisterExtensionKeyword(const Extension* extension) {
356  const TemplateURL* url = GetTemplateURLForExtension(extension);
357  if (url)
358    Remove(url);
359}
360
361const TemplateURL* TemplateURLModel::GetTemplateURLForExtension(
362    const Extension* extension) const {
363  for (TemplateURLVector::const_iterator i = template_urls_.begin();
364       i != template_urls_.end(); ++i) {
365    if ((*i)->IsExtensionKeyword() && (*i)->url()->GetHost() == extension->id())
366      return *i;
367  }
368
369  return NULL;
370}
371
372std::vector<const TemplateURL*> TemplateURLModel::GetTemplateURLs() const {
373  return template_urls_;
374}
375
376void TemplateURLModel::IncrementUsageCount(const TemplateURL* url) {
377  DCHECK(url && find(template_urls_.begin(), template_urls_.end(), url) !=
378         template_urls_.end());
379  const_cast<TemplateURL*>(url)->set_usage_count(url->usage_count() + 1);
380  if (service_.get())
381    service_.get()->UpdateKeyword(*url);
382}
383
384void TemplateURLModel::ResetTemplateURL(const TemplateURL* url,
385                                        const string16& title,
386                                        const string16& keyword,
387                                        const std::string& search_url) {
388  TemplateURL new_url(*url);
389  new_url.set_short_name(title);
390  new_url.set_keyword(keyword);
391  if ((new_url.url() && search_url.empty()) ||
392      (!new_url.url() && !search_url.empty()) ||
393      (new_url.url() && new_url.url()->url() != search_url)) {
394    // The urls have changed, reset the favicon url.
395    new_url.SetFaviconURL(GURL());
396    new_url.SetURL(search_url, 0, 0);
397  }
398  new_url.set_safe_for_autoreplace(false);
399  UpdateNoNotify(url, new_url);
400  NotifyObservers();
401}
402
403bool TemplateURLModel::CanMakeDefault(const TemplateURL* url) {
404  return url != GetDefaultSearchProvider() &&
405      url->url() &&
406      url->url()->SupportsReplacement() &&
407      !is_default_search_managed();
408}
409
410void TemplateURLModel::SetDefaultSearchProvider(const TemplateURL* url) {
411  if (is_default_search_managed_) {
412    NOTREACHED();
413    return;
414  }
415  if (default_search_provider_ == url)
416    return;
417  SetDefaultSearchProviderNoNotify(url);
418  NotifyObservers();
419}
420
421const TemplateURL* TemplateURLModel::GetDefaultSearchProvider() {
422  if (loaded_ && !load_failed_)
423    return default_search_provider_;
424
425  // We're not loaded, rely on the default search provider stored in prefs.
426  return initial_default_search_provider_.get();
427}
428
429void TemplateURLModel::AddObserver(TemplateURLModelObserver* observer) {
430  model_observers_.AddObserver(observer);
431}
432
433void TemplateURLModel::RemoveObserver(TemplateURLModelObserver* observer) {
434  model_observers_.RemoveObserver(observer);
435}
436
437void TemplateURLModel::Load() {
438  if (loaded_ || load_handle_)
439    return;
440
441  if (!service_.get())
442    service_ = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
443
444  if (service_.get()) {
445    load_handle_ = service_->GetKeywords(this);
446  } else {
447    ChangeToLoadedState();
448    NotifyLoaded();
449  }
450}
451
452void TemplateURLModel::OnWebDataServiceRequestDone(
453    WebDataService::Handle h,
454    const WDTypedResult* result) {
455  // Reset the load_handle so that we don't try and cancel the load in
456  // the destructor.
457  load_handle_ = 0;
458
459  if (!result) {
460    // Results are null if the database went away or (most likely) wasn't
461    // loaded.
462    load_failed_ = true;
463    ChangeToLoadedState();
464    NotifyLoaded();
465    return;
466  }
467
468  // initial_default_search_provider_ is only needed before we've finished
469  // loading. Now that we've loaded we can nuke it.
470  initial_default_search_provider_.reset();
471  is_default_search_managed_ = false;
472
473  std::vector<TemplateURL*> template_urls;
474  const TemplateURL* default_search_provider = NULL;
475  int new_resource_keyword_version = 0;
476  GetSearchProvidersUsingKeywordResult(*result,
477                                       service_.get(),
478                                       GetPrefs(),
479                                       &template_urls,
480                                       &default_search_provider,
481                                       &new_resource_keyword_version);
482
483  bool database_specified_a_default = NULL != default_search_provider;
484
485  // Remove entries that were created because of policy as they may have
486  // changed since the database was saved.
487  RemoveProvidersCreatedByPolicy(&template_urls, &default_search_provider);
488
489  // Check if default search provider is now managed.
490  scoped_ptr<TemplateURL> default_from_prefs;
491  LoadDefaultSearchProviderFromPrefs(&default_from_prefs,
492                                     &is_default_search_managed_);
493
494  if (is_default_search_managed_) {
495    SetTemplateURLs(template_urls);
496    // Set the default.  AddNoNotify will take ownership of default_from_prefs
497    // so it is safe to release.  If it's null, there's no ownership to worry
498    // about :-)
499    TemplateURL* managed_default = default_from_prefs.release();
500    if (managed_default) {
501      managed_default->set_created_by_policy(true);
502      managed_default->set_id(0);
503      AddNoNotify(managed_default);
504    }
505    // Note that this saves the default search provider to prefs.
506    SetDefaultSearchProviderNoNotify(managed_default);
507  } else {
508    // If we had a managed default, replace it with the first provider of
509    // the list.
510    if (database_specified_a_default &&
511        NULL == default_search_provider &&
512        !template_urls.empty())
513      default_search_provider = template_urls[0];
514
515    // If the default search provider existed previously, then just
516    // set the member variable. Otherwise, we'll set it using the method
517    // to ensure that it is saved properly after its id is set.
518    if (default_search_provider && default_search_provider->id() != 0) {
519      default_search_provider_ = default_search_provider;
520      default_search_provider = NULL;
521    }
522    SetTemplateURLs(template_urls);
523
524    if (default_search_provider) {
525      // Note that this saves the default search provider to prefs.
526      SetDefaultSearchProvider(default_search_provider);
527    } else {
528      // Always save the default search provider to prefs. That way we don't
529      // have to worry about it being out of sync.
530      if (default_search_provider_)
531        SaveDefaultSearchProviderToPrefs(default_search_provider_);
532    }
533  }
534
535  // This initializes provider_map_ which should be done before
536  // calling UpdateKeywordSearchTermsForURL.
537  ChangeToLoadedState();
538
539  // Index any visits that occurred before we finished loading.
540  for (size_t i = 0; i < visits_to_add_.size(); ++i)
541    UpdateKeywordSearchTermsForURL(visits_to_add_[i]);
542  visits_to_add_.clear();
543
544  if (new_resource_keyword_version && service_.get())
545    service_->SetBuiltinKeywordVersion(new_resource_keyword_version);
546
547  NotifyObservers();
548  NotifyLoaded();
549}
550
551string16 TemplateURLModel::GetKeywordShortName(const string16& keyword,
552                                               bool* is_extension_keyword) {
553  const TemplateURL* template_url = GetTemplateURLForKeyword(keyword);
554
555  // TODO(sky): Once LocationBarView adds a listener to the TemplateURLModel
556  // to track changes to the model, this should become a DCHECK.
557  if (template_url) {
558    *is_extension_keyword = template_url->IsExtensionKeyword();
559    return template_url->AdjustedShortNameForLocaleDirection();
560  }
561  *is_extension_keyword = false;
562  return string16();
563}
564
565void TemplateURLModel::Observe(NotificationType type,
566                               const NotificationSource& source,
567                               const NotificationDetails& details) {
568  if (type == NotificationType::HISTORY_URL_VISITED) {
569    Details<history::URLVisitedDetails> visit_details(details);
570    if (!loaded())
571      visits_to_add_.push_back(*visit_details.ptr());
572    else
573      UpdateKeywordSearchTermsForURL(*visit_details.ptr());
574  } else if (type == NotificationType::GOOGLE_URL_UPDATED) {
575    if (loaded_)
576      GoogleBaseURLChanged();
577  } else if (type == NotificationType::PREF_CHANGED) {
578    const std::string* pref_name = Details<std::string>(details).ptr();
579    if (!pref_name || default_search_prefs_->IsObserved(*pref_name)) {
580      // A preference related to default search engine has changed.
581      // Update the model if needed.
582      UpdateDefaultSearch();
583    }
584  } else {
585    NOTREACHED();
586  }
587}
588
589// static
590void TemplateURLModel::RegisterUserPrefs(PrefService* prefs) {
591  prefs->RegisterBooleanPref(
592      prefs::kDefaultSearchProviderEnabled, true);
593  prefs->RegisterStringPref(
594      prefs::kDefaultSearchProviderName, std::string());
595  prefs->RegisterStringPref(
596      prefs::kDefaultSearchProviderID, std::string());
597  prefs->RegisterStringPref(
598      prefs::kDefaultSearchProviderPrepopulateID, std::string());
599  prefs->RegisterStringPref(
600      prefs::kDefaultSearchProviderSuggestURL, std::string());
601  prefs->RegisterStringPref(
602      prefs::kDefaultSearchProviderSearchURL, std::string());
603  prefs->RegisterStringPref(
604      prefs::kDefaultSearchProviderInstantURL, std::string());
605  prefs->RegisterStringPref(
606      prefs::kDefaultSearchProviderKeyword, std::string());
607  prefs->RegisterStringPref(
608      prefs::kDefaultSearchProviderIconURL, std::string());
609  prefs->RegisterStringPref(
610      prefs::kDefaultSearchProviderEncodings, std::string());
611}
612
613void TemplateURLModel::SetKeywordSearchTermsForURL(const TemplateURL* t_url,
614                                                   const GURL& url,
615                                                   const string16& term) {
616  HistoryService* history = profile_  ?
617      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) : NULL;
618  if (!history)
619    return;
620  history->SetKeywordSearchTermsForURL(url, t_url->id(), term);
621}
622
623void TemplateURLModel::Init(const Initializer* initializers,
624                            int num_initializers) {
625  // Register for notifications.
626  if (profile_) {
627    // TODO(sky): bug 1166191. The keywords should be moved into the history
628    // db, which will mean we no longer need this notification and the history
629    // backend can handle automatically adding the search terms as the user
630    // navigates.
631    registrar_.Add(this, NotificationType::HISTORY_URL_VISITED,
632                   Source<Profile>(profile_->GetOriginalProfile()));
633    PrefService* prefs = GetPrefs();
634    default_search_prefs_.reset(
635        PrefSetObserver::CreateDefaultSearchPrefSetObserver(prefs, this));
636  }
637  registrar_.Add(this, NotificationType::GOOGLE_URL_UPDATED,
638                 NotificationService::AllSources());
639
640  if (num_initializers > 0) {
641    // This path is only hit by test code and is used to simulate a loaded
642    // TemplateURLModel.
643    ChangeToLoadedState();
644
645    // Add specific initializers, if any.
646    for (int i(0); i < num_initializers; ++i) {
647      DCHECK(initializers[i].keyword);
648      DCHECK(initializers[i].url);
649      DCHECK(initializers[i].content);
650
651      size_t template_position =
652          std::string(initializers[i].url).find(kTemplateParameter);
653      DCHECK(template_position != std::string::npos);
654      std::string osd_url(initializers[i].url);
655      osd_url.replace(template_position, arraysize(kTemplateParameter) - 1,
656                      kSearchTermParameter);
657
658      // TemplateURLModel ends up owning the TemplateURL, don't try and free it.
659      TemplateURL* template_url = new TemplateURL();
660      template_url->set_keyword(UTF8ToUTF16(initializers[i].keyword));
661      template_url->set_short_name(UTF8ToUTF16(initializers[i].content));
662      template_url->SetURL(osd_url, 0, 0);
663      AddNoNotify(template_url);
664    }
665  }
666
667  // Initialize default search.
668  UpdateDefaultSearch();
669
670  // Request a server check for the correct Google URL if Google is the
671  // default search engine, not in headless mode and not in Chrome Frame.
672  if (initial_default_search_provider_.get()) {
673    const TemplateURLRef* default_provider_ref =
674        initial_default_search_provider_->url();
675    if (default_provider_ref && default_provider_ref->HasGoogleBaseURLs()) {
676      scoped_ptr<base::Environment> env(base::Environment::Create());
677      if (!env->HasVar(env_vars::kHeadless) &&
678          !CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame))
679        GoogleURLTracker::RequestServerCheck();
680    }
681  }
682}
683
684void TemplateURLModel::RemoveFromMaps(const TemplateURL* template_url) {
685  if (!template_url->keyword().empty())
686    keyword_to_template_map_.erase(template_url->keyword());
687  if (loaded_)
688    provider_map_.Remove(template_url);
689}
690
691void TemplateURLModel::RemoveFromKeywordMapByPointer(
692    const TemplateURL* template_url) {
693  DCHECK(template_url);
694  for (KeywordToTemplateMap::iterator i = keyword_to_template_map_.begin();
695       i != keyword_to_template_map_.end(); ++i) {
696    if (i->second == template_url) {
697      keyword_to_template_map_.erase(i);
698      // A given TemplateURL only occurs once in the map. As soon as we find the
699      // entry, stop.
700      break;
701    }
702  }
703}
704
705void TemplateURLModel::AddToMaps(const TemplateURL* template_url) {
706  if (!template_url->keyword().empty())
707    keyword_to_template_map_[template_url->keyword()] = template_url;
708  if (loaded_) {
709    UIThreadSearchTermsData search_terms_data;
710    provider_map_.Add(template_url, search_terms_data);
711  }
712}
713
714void TemplateURLModel::SetTemplateURLs(const std::vector<TemplateURL*>& urls) {
715  // Add mappings for the new items.
716
717  // First, add the items that already have id's, so that the next_id_
718  // gets properly set.
719  for (std::vector<TemplateURL*>::const_iterator i = urls.begin();
720       i != urls.end();
721       ++i) {
722    if ((*i)->id() == 0)
723      continue;
724    next_id_ = std::max(next_id_, (*i)->id());
725    AddToMaps(*i);
726    template_urls_.push_back(*i);
727  }
728
729  // Next add the new items that don't have id's.
730  for (std::vector<TemplateURL*>::const_iterator i = urls.begin();
731       i != urls.end();
732       ++i) {
733    if ((*i)->id() != 0)
734      continue;
735    AddNoNotify(*i);
736  }
737}
738
739void TemplateURLModel::ChangeToLoadedState() {
740  DCHECK(!loaded_);
741
742  UIThreadSearchTermsData search_terms_data;
743  provider_map_.Init(template_urls_, search_terms_data);
744  loaded_ = true;
745}
746
747void TemplateURLModel::NotifyLoaded() {
748  NotificationService::current()->Notify(
749      NotificationType::TEMPLATE_URL_MODEL_LOADED,
750      Source<TemplateURLModel>(this),
751      NotificationService::NoDetails());
752
753  for (size_t i = 0; i < pending_extension_ids_.size(); ++i) {
754    const Extension* extension = profile_->GetExtensionService()->
755        GetExtensionById(pending_extension_ids_[i], true);
756    if (extension)
757      RegisterExtensionKeyword(extension);
758  }
759  pending_extension_ids_.clear();
760}
761
762void TemplateURLModel::SaveDefaultSearchProviderToPrefs(
763    const TemplateURL* t_url) {
764  PrefService* prefs = GetPrefs();
765  if (!prefs)
766    return;
767
768  bool enabled = false;
769  std::string search_url;
770  std::string suggest_url;
771  std::string instant_url;
772  std::string icon_url;
773  std::string encodings;
774  std::string short_name;
775  std::string keyword;
776  std::string id_string;
777  std::string prepopulate_id;
778  if (t_url) {
779    enabled = true;
780    if (t_url->url())
781      search_url = t_url->url()->url();
782    if (t_url->suggestions_url())
783      suggest_url = t_url->suggestions_url()->url();
784    if (t_url->instant_url())
785      instant_url = t_url->instant_url()->url();
786    GURL icon_gurl = t_url->GetFaviconURL();
787    if (!icon_gurl.is_empty())
788      icon_url = icon_gurl.spec();
789    encodings = JoinString(t_url->input_encodings(), ';');
790    short_name = UTF16ToUTF8(t_url->short_name());
791    keyword = UTF16ToUTF8(t_url->keyword());
792    id_string = base::Int64ToString(t_url->id());
793    prepopulate_id = base::Int64ToString(t_url->prepopulate_id());
794  }
795  prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, enabled);
796  prefs->SetString(prefs::kDefaultSearchProviderSearchURL, search_url);
797  prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, suggest_url);
798  prefs->SetString(prefs::kDefaultSearchProviderInstantURL, instant_url);
799  prefs->SetString(prefs::kDefaultSearchProviderIconURL, icon_url);
800  prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
801  prefs->SetString(prefs::kDefaultSearchProviderName, short_name);
802  prefs->SetString(prefs::kDefaultSearchProviderKeyword, keyword);
803  prefs->SetString(prefs::kDefaultSearchProviderID, id_string);
804  prefs->SetString(prefs::kDefaultSearchProviderPrepopulateID, prepopulate_id);
805
806  prefs->ScheduleSavePersistentPrefs();
807}
808
809bool TemplateURLModel::LoadDefaultSearchProviderFromPrefs(
810    scoped_ptr<TemplateURL>* default_provider,
811    bool* is_managed) {
812  PrefService* prefs = GetPrefs();
813  if (!prefs || !prefs->HasPrefPath(prefs::kDefaultSearchProviderSearchURL))
814    return false;
815
816  const PrefService::Preference* pref =
817      prefs->FindPreference(prefs::kDefaultSearchProviderSearchURL);
818  *is_managed = pref && pref->IsManaged();
819
820  bool enabled =
821      prefs->GetBoolean(prefs::kDefaultSearchProviderEnabled);
822  std::string suggest_url =
823      prefs->GetString(prefs::kDefaultSearchProviderSuggestURL);
824  std::string search_url =
825      prefs->GetString(prefs::kDefaultSearchProviderSearchURL);
826  std::string instant_url =
827      prefs->GetString(prefs::kDefaultSearchProviderInstantURL);
828
829  if (!enabled || (suggest_url.empty() && search_url.empty())) {
830    // The user doesn't want a default search provider.
831    default_provider->reset(NULL);
832    return true;
833  }
834
835  string16 name =
836      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderName));
837  string16 keyword =
838      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
839  std::string icon_url =
840      prefs->GetString(prefs::kDefaultSearchProviderIconURL);
841  std::string encodings =
842      prefs->GetString(prefs::kDefaultSearchProviderEncodings);
843  std::string id_string = prefs->GetString(prefs::kDefaultSearchProviderID);
844  std::string prepopulate_id =
845      prefs->GetString(prefs::kDefaultSearchProviderPrepopulateID);
846
847  default_provider->reset(new TemplateURL());
848  (*default_provider)->set_short_name(name);
849  (*default_provider)->SetURL(search_url, 0, 0);
850  (*default_provider)->SetSuggestionsURL(suggest_url, 0, 0);
851  (*default_provider)->SetInstantURL(instant_url, 0, 0);
852  (*default_provider)->set_keyword(keyword);
853  (*default_provider)->SetFaviconURL(GURL(icon_url));
854  std::vector<std::string> encodings_vector;
855  base::SplitString(encodings, ';', &encodings_vector);
856  (*default_provider)->set_input_encodings(encodings_vector);
857  if (!id_string.empty() && !*is_managed) {
858    int64 value;
859    base::StringToInt64(id_string, &value);
860    (*default_provider)->set_id(value);
861  }
862  if (!prepopulate_id.empty() && !*is_managed) {
863    int value;
864    base::StringToInt(prepopulate_id, &value);
865    (*default_provider)->set_prepopulate_id(value);
866  }
867  (*default_provider)->set_show_in_default_list(true);
868  return true;
869}
870
871static bool TemplateURLsHaveSamePrefs(const TemplateURL* url1,
872                                      const TemplateURL* url2) {
873  if (url1 == url2)
874    return true;
875  return NULL != url1 &&
876      NULL != url2 &&
877      url1->short_name() == url2->short_name() &&
878      url1->keyword() == url2->keyword() &&
879      TemplateURLRef::SameUrlRefs(url1->url(), url2->url()) &&
880      TemplateURLRef::SameUrlRefs(url1->suggestions_url(),
881                                  url2->suggestions_url()) &&
882      url1->GetFaviconURL() == url2->GetFaviconURL() &&
883      url1->safe_for_autoreplace() == url2->safe_for_autoreplace() &&
884      url1->show_in_default_list() == url2->show_in_default_list() &&
885      url1->input_encodings() == url2->input_encodings();
886}
887
888
889bool TemplateURLModel::CanReplaceKeywordForHost(
890    const std::string& host,
891    const TemplateURL** to_replace) {
892  const TemplateURLSet* urls = provider_map_.GetURLsForHost(host);
893  if (urls) {
894    for (TemplateURLSet::const_iterator i = urls->begin();
895         i != urls->end(); ++i) {
896      const TemplateURL* url = *i;
897      if (CanReplace(url)) {
898        if (to_replace)
899          *to_replace = url;
900        return true;
901      }
902    }
903  }
904
905  if (to_replace)
906    *to_replace = NULL;
907  return !urls;
908}
909
910bool TemplateURLModel::CanReplace(const TemplateURL* t_url) {
911  return (t_url != default_search_provider_ && !t_url->show_in_default_list() &&
912          t_url->safe_for_autoreplace());
913}
914
915void TemplateURLModel::UpdateNoNotify(const TemplateURL* existing_turl,
916                                      const TemplateURL& new_values) {
917  DCHECK(loaded_);
918  DCHECK(existing_turl);
919  DCHECK(find(template_urls_.begin(), template_urls_.end(), existing_turl) !=
920         template_urls_.end());
921
922  if (!existing_turl->keyword().empty())
923    keyword_to_template_map_.erase(existing_turl->keyword());
924
925  // This call handles copying over the values (while retaining the id).
926  UIThreadSearchTermsData search_terms_data;
927  provider_map_.Update(existing_turl, new_values, search_terms_data);
928
929  if (!existing_turl->keyword().empty())
930    keyword_to_template_map_[existing_turl->keyword()] = existing_turl;
931
932  if (service_.get())
933    service_->UpdateKeyword(*existing_turl);
934
935  if (default_search_provider_ == existing_turl)
936    SetDefaultSearchProviderNoNotify(existing_turl);
937}
938
939PrefService* TemplateURLModel::GetPrefs() {
940  return profile_ ? profile_->GetPrefs() : NULL;
941}
942
943void TemplateURLModel::UpdateKeywordSearchTermsForURL(
944    const history::URLVisitedDetails& details) {
945  const history::URLRow& row = details.row;
946  if (!row.url().is_valid() ||
947      !row.url().parsed_for_possibly_invalid_spec().query.is_nonempty()) {
948    return;
949  }
950
951  const TemplateURLSet* urls_for_host =
952      provider_map_.GetURLsForHost(row.url().host());
953  if (!urls_for_host)
954    return;
955
956  QueryTerms query_terms;
957  bool built_terms = false;  // Most URLs won't match a TemplateURLs host;
958                             // so we lazily build the query_terms.
959  const std::string path = row.url().path();
960
961  for (TemplateURLSet::const_iterator i = urls_for_host->begin();
962       i != urls_for_host->end(); ++i) {
963    const TemplateURLRef* search_ref = (*i)->url();
964
965    // Count the URL against a TemplateURL if the host and path of the
966    // visited URL match that of the TemplateURL as well as the search term's
967    // key of the TemplateURL occurring in the visited url.
968    //
969    // NOTE: Even though we're iterating over TemplateURLs indexed by the host
970    // of the URL we still need to call GetHost on the search_ref. In
971    // particular, GetHost returns an empty string if search_ref doesn't support
972    // replacement or isn't valid for use in keyword search terms.
973
974    if (search_ref && search_ref->GetHost() == row.url().host() &&
975        search_ref->GetPath() == path) {
976      if (!built_terms && !BuildQueryTerms(row.url(), &query_terms)) {
977        // No query terms. No need to continue with the rest of the
978        // TemplateURLs.
979        return;
980      }
981      built_terms = true;
982
983      if (PageTransition::StripQualifier(details.transition) ==
984          PageTransition::KEYWORD) {
985        // The visit is the result of the user entering a keyword, generate a
986        // KEYWORD_GENERATED visit for the KEYWORD so that the keyword typed
987        // count is boosted.
988        AddTabToSearchVisit(**i);
989      }
990
991      QueryTerms::iterator terms_iterator =
992          query_terms.find(search_ref->GetSearchTermKey());
993      if (terms_iterator != query_terms.end() &&
994          !terms_iterator->second.empty()) {
995        SetKeywordSearchTermsForURL(
996            *i, row.url(), search_ref->SearchTermToString16(*(*i),
997            terms_iterator->second));
998      }
999    }
1000  }
1001}
1002
1003void TemplateURLModel::AddTabToSearchVisit(const TemplateURL& t_url) {
1004  // Only add visits for entries the user hasn't modified. If the user modified
1005  // the entry the keyword may no longer correspond to the host name. It may be
1006  // possible to do something more sophisticated here, but it's so rare as to
1007  // not be worth it.
1008  if (!t_url.safe_for_autoreplace())
1009    return;
1010
1011  if (!profile_)
1012    return;
1013
1014  HistoryService* history =
1015      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
1016  if (!history)
1017    return;
1018
1019  GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(t_url.keyword()),
1020                                   std::string()));
1021  if (!url.is_valid())
1022    return;
1023
1024  // Synthesize a visit for the keyword. This ensures the url for the keyword is
1025  // autocompleted even if the user doesn't type the url in directly.
1026  history->AddPage(url, NULL, 0, GURL(),
1027                   PageTransition::KEYWORD_GENERATED,
1028                   history::RedirectList(), history::SOURCE_BROWSED, false);
1029}
1030
1031// static
1032bool TemplateURLModel::BuildQueryTerms(const GURL& url,
1033                                       QueryTerms* query_terms) {
1034  url_parse::Component query = url.parsed_for_possibly_invalid_spec().query;
1035  url_parse::Component key, value;
1036  size_t valid_term_count = 0;
1037  while (url_parse::ExtractQueryKeyValue(url.spec().c_str(), &query, &key,
1038                                         &value)) {
1039    if (key.is_nonempty() && value.is_nonempty()) {
1040      std::string key_string = url.spec().substr(key.begin, key.len);
1041      std::string value_string = url.spec().substr(value.begin, value.len);
1042      QueryTerms::iterator query_terms_iterator =
1043          query_terms->find(key_string);
1044      if (query_terms_iterator != query_terms->end()) {
1045        if (!query_terms_iterator->second.empty() &&
1046            query_terms_iterator->second != value_string) {
1047          // The term occurs in multiple places with different values. Treat
1048          // this as if the term doesn't occur by setting the value to an empty
1049          // string.
1050          (*query_terms)[key_string] = std::string();
1051          DCHECK(valid_term_count > 0);
1052          valid_term_count--;
1053        }
1054      } else {
1055        valid_term_count++;
1056        (*query_terms)[key_string] = value_string;
1057      }
1058    }
1059  }
1060  return (valid_term_count > 0);
1061}
1062
1063void TemplateURLModel::GoogleBaseURLChanged() {
1064  bool something_changed = false;
1065  for (size_t i = 0; i < template_urls_.size(); ++i) {
1066    const TemplateURL* t_url = template_urls_[i];
1067    if ((t_url->url() && t_url->url()->HasGoogleBaseURLs()) ||
1068        (t_url->suggestions_url() &&
1069         t_url->suggestions_url()->HasGoogleBaseURLs())) {
1070      RemoveFromKeywordMapByPointer(t_url);
1071      t_url->InvalidateCachedValues();
1072      if (!t_url->keyword().empty())
1073        keyword_to_template_map_[t_url->keyword()] = t_url;
1074      something_changed = true;
1075    }
1076  }
1077
1078  if (something_changed && loaded_) {
1079    UIThreadSearchTermsData search_terms_data;
1080    provider_map_.UpdateGoogleBaseURLs(search_terms_data);
1081    NotifyObservers();
1082  }
1083}
1084
1085void TemplateURLModel::UpdateDefaultSearch() {
1086  if (!loaded_) {
1087    // Set |initial_default_search_provider_| from the preferences.  We use this
1088    // value for default search provider until the database has been loaded.
1089    if (!LoadDefaultSearchProviderFromPrefs(&initial_default_search_provider_,
1090                                            &is_default_search_managed_)) {
1091      // Prefs does not specify, so rely on the prepopulated engines.  This
1092      // should happen only the first time Chrome is started.
1093      initial_default_search_provider_.reset(
1094          TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(GetPrefs()));
1095      is_default_search_managed_ = false;
1096    }
1097    return;
1098  }
1099  // Load the default search specified in prefs.
1100  scoped_ptr<TemplateURL> new_default_from_prefs;
1101  bool new_is_default_managed = false;
1102  // Load the default from prefs.  It's possible that it won't succeed
1103  // because we are in the middle of doing SaveDefaultSearchProviderToPrefs()
1104  // and all the preference items have not been saved.  In that case, we
1105  // don't have yet a default.  It would be much better if we could save
1106  // preferences in batches and trigger notifications at the end.
1107  LoadDefaultSearchProviderFromPrefs(&new_default_from_prefs,
1108                                     &new_is_default_managed);
1109  if (!is_default_search_managed_ && !new_is_default_managed) {
1110    // We're not interested in cases where the default was and remains
1111    // unmanaged.  In that case, preferences have no impact on the default.
1112    return;
1113  }
1114  if (is_default_search_managed_ && new_is_default_managed) {
1115    // The default was managed and remains managed.  Update the default only
1116    // if it has changed; we don't want to respond to changes triggered by
1117    // SaveDefaultSearchProviderToPrefs.
1118    if (TemplateURLsHaveSamePrefs(default_search_provider_,
1119                                  new_default_from_prefs.get()))
1120      return;
1121    if (new_default_from_prefs.get() == NULL) {
1122      // default_search_provider_ can't be NULL otherwise
1123      // TemplateURLsHaveSamePrefs would have returned true.  Remove this now
1124      // invalid value.
1125      const TemplateURL* old_default = default_search_provider_;
1126      SetDefaultSearchProviderNoNotify(NULL);
1127      RemoveNoNotify(old_default);
1128    } else if (default_search_provider_) {
1129      new_default_from_prefs->set_created_by_policy(true);
1130      UpdateNoNotify(default_search_provider_, *new_default_from_prefs.get());
1131    } else {
1132      // AddNoNotify will take ownership of new_template, so it's safe to
1133      // release.
1134      TemplateURL* new_template = new_default_from_prefs.release();
1135      if (new_template) {
1136        new_template->set_created_by_policy(true);
1137        AddNoNotify(new_template);
1138      }
1139      SetDefaultSearchProviderNoNotify(new_template);
1140    }
1141  } else if (!is_default_search_managed_ && new_is_default_managed) {
1142    // The default used to be unmanaged and is now managed.  Add the new
1143    // managed default to the list of URLs and set it as default.
1144    is_default_search_managed_ = new_is_default_managed;
1145    // AddNoNotify will take ownership of new_template, so it's safe to
1146    // release.
1147    TemplateURL* new_template = new_default_from_prefs.release();
1148    if (new_template) {
1149      new_template->set_created_by_policy(true);
1150      AddNoNotify(new_template);
1151    }
1152    SetDefaultSearchProviderNoNotify(new_template);
1153  } else {
1154    // The default was managed and is no longer.
1155    DCHECK(is_default_search_managed_ && !new_is_default_managed);
1156    is_default_search_managed_ = new_is_default_managed;
1157    // If we had a default, delete the previous default if created by policy
1158    // and set a likely default.
1159    if (NULL != default_search_provider_ &&
1160        default_search_provider_->created_by_policy()) {
1161      const TemplateURL* old_default = default_search_provider_;
1162      default_search_provider_ = NULL;
1163      RemoveNoNotify(old_default);
1164    }
1165    SetDefaultSearchProviderNoNotify(FindNewDefaultSearchProvider());
1166  }
1167  NotifyObservers();
1168}
1169
1170const TemplateURL* TemplateURLModel::FindNewDefaultSearchProvider() {
1171  // See if the prepoluated default still exists.
1172  scoped_ptr<TemplateURL> prepopulated_default(
1173      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(GetPrefs()));
1174  for (TemplateURLVector::iterator i = template_urls_.begin();
1175      i != template_urls_.end(); ) {
1176    if ((*i)->prepopulate_id() == prepopulated_default->prepopulate_id())
1177      return *i;
1178  }
1179  // If not, use the first of the templates.
1180  if (!template_urls_.empty()) {
1181    return template_urls_[0];
1182  }
1183  return NULL;
1184}
1185
1186void TemplateURLModel::SetDefaultSearchProviderNoNotify(
1187    const TemplateURL* url) {
1188  DCHECK(!url || find(template_urls_.begin(), template_urls_.end(), url) !=
1189         template_urls_.end());
1190  default_search_provider_ = url;
1191
1192  if (url) {
1193    TemplateURL* modifiable_url = const_cast<TemplateURL*>(url);
1194    // Don't mark the url as edited, otherwise we won't be able to rev the
1195    // template urls we ship with.
1196    modifiable_url->set_show_in_default_list(true);
1197    if (service_.get())
1198      service_.get()->UpdateKeyword(*url);
1199
1200    const TemplateURLRef* url_ref = url->url();
1201    if (url_ref && url_ref->HasGoogleBaseURLs()) {
1202      GoogleURLTracker::RequestServerCheck();
1203#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
1204      RLZTracker::RecordProductEvent(rlz_lib::CHROME,
1205                                     rlz_lib::CHROME_OMNIBOX,
1206                                     rlz_lib::SET_TO_GOOGLE);
1207#endif
1208    }
1209  }
1210
1211  if (!is_default_search_managed_)
1212    SaveDefaultSearchProviderToPrefs(url);
1213
1214  if (service_.get())
1215    service_->SetDefaultSearchProvider(url);
1216}
1217
1218void TemplateURLModel::AddNoNotify(TemplateURL* template_url) {
1219  DCHECK(template_url);
1220  DCHECK(template_url->id() == 0);
1221  DCHECK(find(template_urls_.begin(), template_urls_.end(), template_url) ==
1222         template_urls_.end());
1223  template_url->set_id(++next_id_);
1224  template_urls_.push_back(template_url);
1225  AddToMaps(template_url);
1226
1227  if (service_.get())
1228    service_->AddKeyword(*template_url);
1229}
1230
1231void TemplateURLModel::RemoveNoNotify(const TemplateURL* template_url) {
1232  TemplateURLVector::iterator i = find(template_urls_.begin(),
1233                                       template_urls_.end(),
1234                                       template_url);
1235  if (i == template_urls_.end())
1236    return;
1237
1238  if (template_url == default_search_provider_) {
1239    // Should never delete the default search provider.
1240    NOTREACHED();
1241    return;
1242  }
1243
1244  RemoveFromMaps(template_url);
1245
1246  // Remove it from the vector containing all TemplateURLs.
1247  template_urls_.erase(i);
1248
1249  if (service_.get())
1250    service_->RemoveKeyword(*template_url);
1251
1252  if (profile_) {
1253    Source<Profile> source(profile_);
1254    TemplateURLID id = template_url->id();
1255    NotificationService::current()->Notify(
1256        NotificationType::TEMPLATE_URL_REMOVED,
1257        source,
1258        Details<TemplateURLID>(&id));
1259  }
1260
1261  // We own the TemplateURL and need to delete it.
1262  delete template_url;
1263}
1264
1265void TemplateURLModel::NotifyObservers() {
1266  if (!loaded_)
1267    return;
1268
1269  FOR_EACH_OBSERVER(TemplateURLModelObserver, model_observers_,
1270                    OnTemplateURLModelChanged());
1271}
1272