Revert of Handle TemplateURLService load failure better, and make some test correctness fixes that will be ne…

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 39 matching lines @@
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "ui/base/l10n/l10n_util.h"
 
 typedef SearchHostToURLsMap::TemplateURLSet TemplateURLSet;
 typedef TemplateURLService::SyncDataMap SyncDataMap;
 
 namespace {
 
+bool TemplateURLMatchesData(const TemplateURL* url1,
+                            const TemplateURLData* url2) {
+  if (!url1 || !url2)
+    return !url1 && !url2;
+
+  return (url1->short_name() == url2->short_name) &&
+         url1->HasSameKeywordAs(*url2) &&
+         (url1->url() == url2->url()) &&
+         (url1->suggestions_url() == url2->suggestions_url) &&
+         (url1->instant_url() == url2->instant_url) &&
+         (url1->image_url() == url2->image_url) &&
+         (url1->new_tab_url() == url2->new_tab_url) &&
+         (url1->search_url_post_params() == url2->search_url_post_params) &&
+         (url1->suggestions_url_post_params() ==
+          url2->suggestions_url_post_params) &&
+         (url1->instant_url_post_params() == url2->instant_url_post_params) &&
+         (url1->image_url_post_params() == url2->image_url_post_params) &&
+         (url1->favicon_url() == url2->favicon_url) &&
+         (url1->safe_for_autoreplace() == url2->safe_for_autoreplace) &&
+         (url1->show_in_default_list() == url2->show_in_default_list) &&
+         (url1->input_encodings() == url2->input_encodings) &&
+         (url1->alternate_urls() == url2->alternate_urls) &&
+         (url1->search_terms_replacement_key() ==
+          url2->search_terms_replacement_key);
+}
+
 const char kFirstPotentialEngineHistogramName[] =
     "Search.FirstPotentialEngineCalled";
 
 // Values for an enumerated histogram used to track whenever
 // FirstPotentialDefaultEngine is called, and from where.
 enum FirstPotentialEngineCaller {
   FIRST_POTENTIAL_CALLSITE_FIND_NEW_DSP,
   FIRST_POTENTIAL_CALLSITE_FIND_NEW_DSP_PROCESSING_SYNC_CHANGES,
   FIRST_POTENTIAL_CALLSITE_ON_LOAD,
   FIRST_POTENTIAL_CALLSITE_FIND_NEW_DSP_SYNCING,
@@ skipping 317 matching lines @@
   }
   if (!prepopulate_id.empty() && !*is_managed) {
     int value;
     base::StringToInt(prepopulate_id, &value);
     (*default_provider_data)->prepopulate_id = value;
   }
   return true;
 }
 
 // static
-base::string16 TemplateURLService::GenerateKeyword(const GURL& url) {
-  DCHECK(url.is_valid());
-  // Strip "www." off the front of the keyword; otherwise the keyword won't work
-  // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
-  // Special case: if the host was exactly "www." (not sure this can happen but
-  // perhaps with some weird intranet and custom DNS server?), ensure we at
-  // least don't return the empty string.
-  base::string16 keyword(net::StripWWWFromHost(url));
-  return keyword.empty() ? base::ASCIIToUTF16("www") : keyword;
-}
-
-// static
-base::string16 TemplateURLService::CleanUserInputKeyword(
-    const base::string16& keyword) {
-  // Remove the scheme.
-  base::string16 result(base::i18n::ToLower(keyword));
-  base::TrimWhitespace(result, base::TRIM_ALL, &result);
-  url::Component scheme_component;
-  if (url::ExtractScheme(base::UTF16ToUTF8(keyword).c_str(),
-                         static_cast<int>(keyword.length()),
-                         &scheme_component)) {
-    // If the scheme isn't "http" or "https", bail.  The user isn't trying to
-    // type a web address, but rather an FTP, file:, or other scheme URL, or a
-    // search query with some sort of initial operator (e.g. "site:").
-    if (result.compare(0, scheme_component.end(),
-                       base::ASCIIToUTF16(url::kHttpScheme)) &&
-        result.compare(0, scheme_component.end(),
-                       base::ASCIIToUTF16(url::kHttpsScheme)))
-      return base::string16();
-
-    // Include trailing ':'.
-    result.erase(0, scheme_component.end() + 1);
-    // Many schemes usually have "//" after them, so strip it too.
-    const base::string16 after_scheme(base::ASCIIToUTF16("//"));
-    if (result.compare(0, after_scheme.length(), after_scheme) == 0)
-      result.erase(0, after_scheme.length());
-  }
-
-  // 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(
-    const TemplateURL* t_url,
-    const SearchTermsData& search_terms_data) {
-  DCHECK(t_url);
-
-  const TemplateURLRef& search_ref = t_url->url_ref();
-  if (!search_ref.IsValidUsingTermsData(search_terms_data))
-    return GURL();
-
-  if (!search_ref.SupportsReplacementUsingTermsData(search_terms_data))
-    return GURL(t_url->url());
-
-  // Use something obscure for the search terms argument so that in the rare
-  // case the term replaces the URL it's unlikely another keyword would have the
-  // same url.
-  // TODO(jnd): Add additional parameters to get post data when the search URL
-  // has post parameters.
-  return GURL(search_ref.ReplaceSearchTermsUsingTermsData(
-      TemplateURLRef::SearchTermsArgs(
-          base::ASCIIToUTF16("blah.blah.blah.blah.blah")),
-      search_terms_data, NULL));
-}
-
 void TemplateURLService::SaveDefaultSearchProviderToPrefs(
-    const TemplateURL* t_url,
-    PrefService* prefs) const {
-  if (!prefs || load_failed_)
+    const TemplateURL* t_url, PrefService* prefs) {
+  if (!prefs)
     return;
 
   bool enabled = false;
   std::string search_url;
   std::string suggest_url;
   std::string instant_url;
   std::string image_url;
   std::string new_tab_url;
   std::string search_url_post_params;
   std::string suggest_url_post_params;
@@ skipping 49 matching lines @@
   prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
   prefs->SetString(prefs::kDefaultSearchProviderName, short_name);
   prefs->SetString(prefs::kDefaultSearchProviderKeyword, keyword);
   prefs->SetString(prefs::kDefaultSearchProviderID, id_string);
   prefs->SetString(prefs::kDefaultSearchProviderPrepopulateID, prepopulate_id);
   prefs->Set(prefs::kDefaultSearchProviderAlternateURLs, alternate_urls);
   prefs->SetString(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
       search_terms_replacement_key);
 }
 
+// static
+base::string16 TemplateURLService::GenerateKeyword(const GURL& url) {
+  DCHECK(url.is_valid());
+  // Strip "www." off the front of the keyword; otherwise the keyword won't work
+  // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
+  // Special case: if the host was exactly "www." (not sure this can happen but
+  // perhaps with some weird intranet and custom DNS server?), ensure we at
+  // least don't return the empty string.
+  base::string16 keyword(net::StripWWWFromHost(url));
+  return keyword.empty() ? base::ASCIIToUTF16("www") : keyword;
+}
+
+// static
+base::string16 TemplateURLService::CleanUserInputKeyword(
+    const base::string16& keyword) {
+  // Remove the scheme.
+  base::string16 result(base::i18n::ToLower(keyword));
+  base::TrimWhitespace(result, base::TRIM_ALL, &result);
+  url::Component scheme_component;
+  if (url::ExtractScheme(base::UTF16ToUTF8(keyword).c_str(),
+                         static_cast<int>(keyword.length()),
+                         &scheme_component)) {
+    // If the scheme isn't "http" or "https", bail.  The user isn't trying to
+    // type a web address, but rather an FTP, file:, or other scheme URL, or a
+    // search query with some sort of initial operator (e.g. "site:").
+    if (result.compare(0, scheme_component.end(),
+                       base::ASCIIToUTF16(url::kHttpScheme)) &&
+        result.compare(0, scheme_component.end(),
+                       base::ASCIIToUTF16(url::kHttpsScheme)))
+      return base::string16();
+
+    // Include trailing ':'.
+    result.erase(0, scheme_component.end() + 1);
+    // Many schemes usually have "//" after them, so strip it too.
+    const base::string16 after_scheme(base::ASCIIToUTF16("//"));
+    if (result.compare(0, after_scheme.length(), after_scheme) == 0)
+      result.erase(0, after_scheme.length());
+  }
+
+  // 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(
+    const TemplateURL* t_url,
+    const SearchTermsData& search_terms_data) {
+  DCHECK(t_url);
+
+  const TemplateURLRef& search_ref = t_url->url_ref();
+  if (!search_ref.IsValidUsingTermsData(search_terms_data))
+    return GURL();
+
+  if (!search_ref.SupportsReplacementUsingTermsData(search_terms_data))
+    return GURL(t_url->url());
+
+  // Use something obscure for the search terms argument so that in the rare
+  // case the term replaces the URL it's unlikely another keyword would have the
+  // same url.
+  // TODO(jnd): Add additional parameters to get post data when the search URL
+  // has post parameters.
+  return GURL(search_ref.ReplaceSearchTermsUsingTermsData(
+      TemplateURLRef::SearchTermsArgs(
+          base::ASCIIToUTF16("blah.blah.blah.blah.blah")),
+      search_terms_data, NULL));
+}
+
 bool TemplateURLService::CanReplaceKeyword(
     const base::string16& keyword,
     const GURL& url,
     TemplateURL** template_url_to_replace) {
   DCHECK(!keyword.empty());  // This should only be called for non-empty
                              // keywords. If we need to support empty kewords
                              // the code needs to change slightly.
   TemplateURL* existing_url = GetTemplateURLForKeyword(keyword);
   if (template_url_to_replace)
     *template_url_to_replace = existing_url;
@@ skipping 222 matching lines @@
 void TemplateURLService::IncrementUsageCount(TemplateURL* url) {
   DCHECK(url);
   // Extension-controlled search engines are not persisted.
   if (url->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)
     return;
   if (std::find(template_urls_.begin(), template_urls_.end(), url) ==
       template_urls_.end())
     return;
   ++url->data_.usage_count;
 
-  if (service_)
-    service_->UpdateKeyword(url->data());
+  if (service_.get())
+    service_.get()->UpdateKeyword(url->data());
 }
 
 void TemplateURLService::ResetTemplateURL(TemplateURL* url,
                                           const base::string16& title,
                                           const base::string16& keyword,
                                           const std::string& search_url) {
-  if (ResetTemplateURLNoNotify(url, title, keyword, search_url))
+  if (!loaded_)
+    return;
+  DCHECK(!keyword.empty());
+  DCHECK(!search_url.empty());
+  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(url->profile(), data);
+  UIThreadSearchTermsData search_terms_data(url->profile());
+  if (UpdateNoNotify(url, new_url, search_terms_data))
     NotifyObservers();
 }
 
 bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
   return  !is_default_search_managed() &&
       !IsExtensionControlledDefaultSearch() &&
       (url != GetDefaultSearchProvider()) &&
       url->url_ref().SupportsReplacement() &&
       (url->GetType() == TemplateURL::NORMAL);
 }
 
 void TemplateURLService::SetUserSelectedDefaultSearchProvider(
     TemplateURL* url) {
   SetDefaultSearchProvider(url);
   if (default_search_manager_) {
     if (url)
       default_search_manager_->SetUserSelectedDefaultSearchEngine(url->data());
     else
       default_search_manager_->ClearUserSelectedDefaultSearchEngine();
   }
 }
 
 TemplateURL* TemplateURLService::GetDefaultSearchProvider() {
-  return (loaded_ && !load_failed_) ?
-      default_search_provider_ : initial_default_search_provider_.get();
+  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();
 }
 
 bool TemplateURLService::IsSearchResultsPageFromDefaultSearchProvider(
     const GURL& url) {
   TemplateURL* default_provider = GetDefaultSearchProvider();
   return default_provider && default_provider->IsSearchURL(url);
 }
 
 bool TemplateURLService::IsExtensionControlledDefaultSearch() {
   const TemplateURL* default_provider = GetDefaultSearchProvider();
@@ skipping 90 matching lines @@
 }
 
 void TemplateURLService::RemoveObserver(TemplateURLServiceObserver* observer) {
   model_observers_.RemoveObserver(observer);
 }
 
 void TemplateURLService::Load() {
   if (loaded_ || load_handle_)
     return;
 
-  if (!service_)
+  if (!service_.get()) {
     service_ = WebDataService::FromBrowserContext(profile_);
+  }
 
-  if (service_) {
+  if (service_.get()) {
     load_handle_ = service_->GetKeywords(this);
   } else {
     ChangeToLoadedState();
     on_loaded_callbacks_.Notify();
   }
 }
 
 scoped_ptr<TemplateURLService::Subscription>
     TemplateURLService::RegisterOnLoadedCallback(
         const base::Closure& callback) {
   return loaded_ ?
       scoped_ptr<TemplateURLService::Subscription>() :
       on_loaded_callbacks_.Add(callback);
 }
 
 void TemplateURLService::OnWebDataServiceRequestDone(
     WebDataService::Handle h,
     const WDTypedResult* result) {
   // Reset the load_handle so that we don't try and cancel the load in
   // the destructor.
   load_handle_ = 0;
 
   if (!result) {
     // Results are null if the database went away or (most likely) wasn't
     // loaded.
     load_failed_ = true;
-    service_ = NULL;
     ChangeToLoadedState();
     on_loaded_callbacks_.Notify();
     return;
   }
 
   // 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();
 
   TemplateURLVector template_urls;
@@ skipping 257 matching lines @@
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK(loaded_);
   DCHECK_EQ(type, syncer::SEARCH_ENGINES);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   syncer::SyncMergeResult merge_result(type);
-
-  // Disable sync if we failed to load.
-  if (load_failed_) {
-    merge_result.set_error(syncer::SyncError(
-        FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-        "Local database load failed.", syncer::SEARCH_ENGINES));
-    return merge_result;
-  }
-
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   // We just started syncing, so set our wait-for-default flag if we are
   // expecting a default from Sync.
   if (GetPrefs()) {
     std::string default_guid = GetPrefs()->GetString(
         prefs::kSyncedDefaultSearchProviderGUID);
     const TemplateURL* current_default = GetDefaultSearchProvider();
 
@@ skipping 369 matching lines @@
       if (i == 0)
         SetDefaultSearchProviderNoNotify(template_url);
     }
   }
 
   // Initialize default search.
   UpdateDefaultSearch();
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine and not in headless mode.
-  if (profile_ && initial_default_search_provider_ &&
-      initial_default_search_provider_->HasGoogleBaseURLs()) {
+  if (profile_ && initial_default_search_provider_.get() &&
+      initial_default_search_provider_->url_ref().HasGoogleBaseURLs()) {
     scoped_ptr<base::Environment> env(base::Environment::Create());
     if (!env->HasVar(env_vars::kHeadless))
       GoogleURLTracker::RequestServerCheck(profile_, false);
   }
 }
 
 void TemplateURLService::RemoveFromMaps(TemplateURL* template_url) {
   const base::string16& keyword = template_url->keyword();
   DCHECK_NE(0U, keyword_to_template_map_.count(keyword));
   if (keyword_to_template_map_[keyword] == template_url) {
@@ skipping 194 matching lines @@
         RemoveNoNotify(existing_keyword_turl);
       } else {
         existing_turl->data_.SetKeyword(old_keyword);
         keyword_to_template_map_[old_keyword] = existing_turl;
       }
     }
   }
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_[existing_turl->sync_guid()] = existing_turl;
 
-  if (service_)
+  if (service_.get())
     service_->UpdateKeyword(existing_turl->data());
 
   // Inform sync of the update.
   ProcessTemplateURLChange(FROM_HERE,
                            existing_turl,
                            syncer::SyncChange::ACTION_UPDATE);
 
   if (default_search_provider_ == existing_turl) {
     bool success = SetDefaultSearchProviderNoNotify(existing_turl);
     DCHECK(success);
@@ skipping 82 matching lines @@
                    content::PAGE_TRANSITION_KEYWORD_GENERATED,
                    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()) {
+    if (t_url->url_ref().HasGoogleBaseURLs() ||
+        t_url->suggestions_url_ref().HasGoogleBaseURLs()) {
       TemplateURL updated_turl(t_url->profile(), t_url->data());
       updated_turl.ResetKeywordIfNecessary(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.)
@@ skipping 48 matching lines @@
   if (!is_default_search_managed_ && !new_is_default_managed) {
     // We're not interested in cases where the default was and remains
     // unmanaged.  In that case, preferences have no impact on the default.
     return;
   }
   WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
   if (is_default_search_managed_ && new_is_default_managed) {
     // The default was managed and remains managed.  Update the default only
     // if it has changed; we don't want to respond to changes triggered by
     // SaveDefaultSearchProviderToPrefs.
-    if (TemplateURL::MatchesData(default_search_provider_,
-                                 new_default_from_prefs.get()))
+    if (TemplateURLMatchesData(default_search_provider_,
+                               new_default_from_prefs.get()))
       return;
     if (!new_default_from_prefs) {
-      // |default_search_provider_| can't be NULL or MatchesData() would have
-      // returned true.  Remove this now invalid value.
+      // default_search_provider_ can't be NULL otherwise
+      // TemplateURLMatchesData would have returned true.  Remove this now
+      // invalid value.
       TemplateURL* old_default = default_search_provider_;
       bool success = SetDefaultSearchProviderNoNotify(NULL);
       DCHECK(success);
       RemoveNoNotify(old_default);
     } else if (default_search_provider_) {
       new_default_from_prefs->created_by_policy = true;
       TemplateURL new_values(profile_, *new_default_from_prefs);
       UIThreadSearchTermsData search_terms_data(
           default_search_provider_->profile());
       UpdateNoNotify(default_search_provider_, new_values, search_terms_data);
@@ skipping 89 matching lines @@
       UMA_HISTOGRAM_ENUMERATION("Search.DefaultSearchChangeOrigin",
                                 dsp_change_origin_, DSP_CHANGE_MAX);
       default_search_provider_ = url;
     }
   }
 
   if (url) {
     // Don't mark the url as edited, otherwise we won't be able to rev the
     // template urls we ship with.
     url->data_.show_in_default_list = true;
-    if (service_ && (url->GetType() == TemplateURL::NORMAL))
+    if (service_.get() && (url->GetType() == TemplateURL::NORMAL))
       service_->UpdateKeyword(url->data());
 
-    if (url->HasGoogleBaseURLs()) {
+    if (url->url_ref().HasGoogleBaseURLs()) {
       GoogleURLTracker::RequestServerCheck(profile_, false);
 #if defined(ENABLE_RLZ)
       RLZTracker::RecordProductEvent(rlz_lib::CHROME,
                                      RLZTracker::CHROME_OMNIBOX,
                                      rlz_lib::SET_TO_GOOGLE);
 #endif
     }
   }
 
   // Extension-controlled search engines shouldn't be persisted anywhere.
@@ skipping 11 matching lines @@
     // needs to set a new default as well. If we update the default here, we're
     // likely to race with the update from the other client, resulting in
     // a possibly random default search provider.
     if (sync_processor_.get() && url && !url->sync_guid().empty() &&
         GetPrefs() && !processing_syncer_changes_) {
       GetPrefs()->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                             url->sync_guid());
     }
   }
 
-  if (service_)
+  if (service_.get())
     service_->SetDefaultSearchProviderID(url ? url->id() : 0);
 
   // Inform sync the change to the show_in_default_list flag.
   if (url)
     ProcessTemplateURLChange(FROM_HERE,
                              url,
                              syncer::SyncChange::ACTION_UPDATE);
   return true;
 }
 
@@ skipping 20 matching lines @@
     bool are_same_type = existing_keyword_turl->GetType() ==
         template_url->GetType();
     if (CanReplace(existing_keyword_turl) && are_same_type) {
       RemoveNoNotify(existing_keyword_turl);
     } else if (CanReplace(template_url) && are_same_type) {
       delete template_url;
       return false;
     } else {
       base::string16 new_keyword =
           UniquifyKeyword(*existing_keyword_turl, false);
-      ResetTemplateURLNoNotify(existing_keyword_turl,
-                               existing_keyword_turl->short_name(), new_keyword,
-                               existing_keyword_turl->url());
+      ResetTemplateURL(existing_keyword_turl,
+                       existing_keyword_turl->short_name(), new_keyword,
+                       existing_keyword_turl->url());
     }
   }
   template_urls_.push_back(template_url);
   AddToMaps(template_url);
 
   if (newly_adding &&
       (template_url->GetType() !=
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)) {
-    if (service_)
+    if (service_.get())
       service_->AddKeyword(template_url->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_template_map_.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_ADD);
   }
 
   return true;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   DCHECK(template_url != default_search_provider_);
 
   TemplateURLVector::iterator i =
       std::find(template_urls_.begin(), template_urls_.end(), template_url);
   if (i == template_urls_.end())
     return;
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   template_urls_.erase(i);
 
   if (template_url->GetType() != TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) {
-    if (service_)
+    if (service_.get())
       service_->RemoveKeyword(template_url->id());
 
     // Inform sync of the deletion.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_DELETE);
 
     UMA_HISTOGRAM_ENUMERATION(kDeleteSyncedEngineHistogramName,
                               DELETE_ENGINE_USER_ACTION, DELETE_ENGINE_MAX);
   }
 
   if (profile_) {
     content::Source<Profile> source(profile_);
     TemplateURLID id = template_url->id();
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
         source,
         content::Details<TemplateURLID>(&id));
   }
 
   // We own the TemplateURL and need to delete it.
   delete template_url;
 }
 
-bool TemplateURLService::ResetTemplateURLNoNotify(
-    TemplateURL* url,
-    const base::string16& title,
-    const base::string16& keyword,
-    const std::string& search_url) {
-  if (!loaded_)
-    return false;
-  DCHECK(!keyword.empty());
-  DCHECK(!search_url.empty());
-  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(url->profile(), data);
-  UIThreadSearchTermsData search_terms_data(url->profile());
-  return UpdateNoNotify(url, new_url, search_terms_data);
-}
-
 void TemplateURLService::NotifyObservers() {
   if (!loaded_)
     return;
 
   FOR_EACH_OBSERVER(TemplateURLServiceObserver, model_observers_,
                     OnTemplateURLServiceChanged());
 }
 
 // |template_urls| are the TemplateURLs loaded from the database.
 // |default_search_provider| points to one of them, if it was set in the db.
 // |default_from_prefs| is the default search provider from the preferences.
 // Check |is_default_search_managed_| to determine if it was set by policy.
 //
 // This function removes from the vector and the database all the TemplateURLs
 // that were set by policy, unless it is the current default search provider
 // and matches what is set by a managed preference.
 void TemplateURLService::RemoveProvidersCreatedByPolicy(
     TemplateURLVector* template_urls,
     TemplateURL** default_search_provider,
     TemplateURLData* default_from_prefs) {
   DCHECK(template_urls);
   DCHECK(default_search_provider);
   for (TemplateURLVector::iterator i = template_urls->begin();
        i != template_urls->end(); ) {
     TemplateURL* template_url = *i;
     if (template_url->created_by_policy()) {
       if (template_url == *default_search_provider &&
           is_default_search_managed_ &&
-          TemplateURL::MatchesData(template_url, default_from_prefs)) {
+          TemplateURLMatchesData(template_url, default_from_prefs)) {
         // If the database specified a default search provider that was set
         // by policy, and the default search provider from the preferences
         // is also set by policy and they are the same, keep the entry in the
         // database and the |default_search_provider|.
         ++i;
         continue;
       }
 
       // The database loaded a managed |default_search_provider|, but it has
       // been updated in the prefs. Remove it from the database, and update the
       // |default_search_provider| pointer here.
       if (*default_search_provider &&
           (*default_search_provider)->id() == template_url->id())
         *default_search_provider = NULL;
 
       i = template_urls->erase(i);
-      if (service_)
+      if (service_.get())
         service_->RemoveKeyword(template_url->id());
       delete template_url;
     } else {
       ++i;
     }
   }
 }
 
 void TemplateURLService::ResetTemplateURLGUID(TemplateURL* url,
                                               const std::string& guid) {
@@ skipping 203 matching lines @@
     TemplateURLVector* template_urls) {
   DCHECK(template_urls);
   for (TemplateURLVector::iterator i = template_urls->begin();
        i != template_urls->end(); ++i) {
     TemplateURL* template_url = *i;
     DCHECK(template_url);
     if (template_url->sync_guid().empty() &&
         (template_url->GetType() !=
             TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)) {
       template_url->data_.sync_guid = base::GenerateGUID();
-      if (service_)
+      if (service_.get())
         service_->UpdateKeyword(template_url->data());
     }
   }
 }
 
 void TemplateURLService::AddTemplateURLsAndSetupDefaultEngine(
     TemplateURLVector* template_urls,
     TemplateURL* default_search_provider) {
   DCHECK(template_urls);
   is_default_search_managed_ = false;
   bool database_specified_a_default = (default_search_provider != NULL);
 
   // Check if default search provider is now managed.
   scoped_ptr<TemplateURLData> default_from_prefs;
   LoadDefaultSearchProviderFromPrefs(
       GetPrefs(), &default_from_prefs, &is_default_search_managed_);
 
   // 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 (TemplateURL::MatchesData(default_search_provider,
-                                 default_from_prefs.get())) {
+    if (TemplateURLMatchesData(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) {
         default_from_prefs->created_by_policy = true;
         default_from_prefs->id = kInvalidTemplateURLID;
         default_search_provider =
             new TemplateURL(profile_, *default_from_prefs);
@@ skipping 128 matching lines @@
           new_dse = *i;
           break;
         }
       }
     }
   }
   if (!new_dse)
     new_dse = FindNewDefaultSearchProvider();
   SetDefaultSearchProviderNoNotify(new_dse);
 }