Make several methods of TemplateUrlService const

components/search_engines/template_url_service.cc

 // Copyright 2014 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 "components/search_engines/template_url_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 325 matching lines @@
   result = url_formatter::StripWWW(result);
 
   // Remove trailing "/".
   return (result.empty() || result.back() != '/') ?
       result : result.substr(0, result.length() - 1);
 }
 
 bool TemplateURLService::CanAddAutogeneratedKeyword(
     const base::string16& keyword,
     const GURL& url,
-    TemplateURL** template_url_to_replace) {
+    TemplateURL** template_url_to_replace) const {
   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;
   if (existing_url) {
     // We already have a TemplateURL for this keyword. Only allow it to be
     // replaced if the TemplateURL can be replaced.
     return CanReplace(existing_url);
   }
 
   // We don't have a TemplateURL with keyword.  We still may not allow this
   // keyword if there's evidence we may have created this keyword before and
   // the user renamed it (because, for instance, the keyword is a common word
   // that may interfere with search queries).  An easy heuristic for this is
   // whether the user has a TemplateURL that has been manually modified (e.g.,
   // renamed) connected to the same host.
   return !url.is_valid() || url.host().empty() ||
       CanAddAutogeneratedKeywordForHost(url.host());
 }
 
 bool TemplateURLService::IsPrepopulatedOrCreatedByPolicy(
-    const TemplateURL* t_url) {
+    const TemplateURL* t_url) const {
   return (t_url->prepopulate_id() > 0 || t_url->created_by_policy()) &&
       t_url->SupportsReplacement(search_terms_data());
 }
 
-bool TemplateURLService::ShowInDefaultList(const TemplateURL* t_url) {
+bool TemplateURLService::ShowInDefaultList(const TemplateURL* t_url) const {
   return t_url == default_search_provider_ ||
       IsPrepopulatedOrCreatedByPolicy(t_url);
 }
 
 void TemplateURLService::AddMatchingKeywords(
     const base::string16& prefix,
     bool supports_replacement_only,
     TURLsAndMeaningfulLengths* matches) {
   AddMatchingKeywordsHelper(
       keyword_to_turl_and_length_, prefix, supports_replacement_only, matches);
 }
 
 void TemplateURLService::AddMatchingDomainKeywords(
     const base::string16& prefix,
     bool supports_replacement_only,
     TURLsAndMeaningfulLengths* matches) {
   AddMatchingKeywordsHelper(
       keyword_domain_to_turl_and_length_, prefix, supports_replacement_only,
       matches);
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForKeyword(
-    const base::string16& keyword) {
+    const base::string16& keyword) const {
   KeywordToTURLAndMeaningfulLength::const_iterator elem(
       keyword_to_turl_and_length_.find(keyword));
   if (elem != keyword_to_turl_and_length_.end())
     return elem->second.first;
   return (!loaded_ && initial_default_search_provider_ &&
           (initial_default_search_provider_->keyword() == keyword))
              ? initial_default_search_provider_.get()
              : nullptr;
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForGUID(
-    const std::string& sync_guid) {
+    const std::string& sync_guid) const {
   GUIDToTURL::const_iterator elem(guid_to_turl_.find(sync_guid));
   if (elem != guid_to_turl_.end())
     return elem->second;
   return (!loaded_ && initial_default_search_provider_ &&
           (initial_default_search_provider_->sync_guid() == sync_guid))
              ? initial_default_search_provider_.get()
              : nullptr;
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForHost(
-    const std::string& host) {
+    const std::string& host) const {
   if (loaded_)
     return provider_map_->GetTemplateURLForHost(host);
   TemplateURL* initial_dsp = initial_default_search_provider_.get();
   return (initial_dsp &&
           (initial_dsp->GenerateSearchURL(search_terms_data()).host_piece() ==
            host))
              ? initial_dsp
              : nullptr;
 }
 
@@ skipping 131 matching lines @@
 }
 
 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))
     NotifyObservers();
 }
 
-bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
+bool TemplateURLService::CanMakeDefault(const TemplateURL* url) const {
   return
       ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
        (default_search_provider_source_ ==
         DefaultSearchManager::FROM_FALLBACK)) &&
       (url != GetDefaultSearchProvider()) &&
       url->url_ref().SupportsReplacement(search_terms_data()) &&
       (url->type() == TemplateURL::NORMAL);
 }
 
 void TemplateURLService::SetUserSelectedDefaultSearchProvider(
@@ skipping 30 matching lines @@
                  : initial_default_search_provider_.get();
 }
 
 bool TemplateURLService::IsSearchResultsPageFromDefaultSearchProvider(
     const GURL& url) const {
   const TemplateURL* default_provider = GetDefaultSearchProvider();
   return default_provider &&
       default_provider->IsSearchURL(url, search_terms_data());
 }
 
-bool TemplateURLService::IsExtensionControlledDefaultSearch() {
+bool TemplateURLService::IsExtensionControlledDefaultSearch() const {
   return default_search_provider_source_ ==
       DefaultSearchManager::FROM_EXTENSION;
 }
 
 void TemplateURLService::RepairPrepopulatedSearchEngines() {
   // Can't clean DB if it hasn't been loaded.
   DCHECK(loaded());
 
   if ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
       (default_search_provider_source_ ==
@@ skipping 207 matching lines @@
           "Search.DefaultSearchProvider", rappor::ETLD_PLUS_ONE_RAPPOR_TYPE,
           net::registry_controlled_domains::GetDomainAndRegistry(
               default_search_provider_->url_ref().GetHost(search_terms_data()),
               net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES));
     }
   }
 }
 
 base::string16 TemplateURLService::GetKeywordShortName(
     const base::string16& keyword,
-    bool* is_omnibox_api_extension_keyword) {
+    bool* is_omnibox_api_extension_keyword) const {
   const TemplateURL* template_url = GetTemplateURLForKeyword(keyword);
 
   // TODO(sky): Once LocationBarView adds a listener to the TemplateURLService
   // to track changes to the model, this should become a DCHECK.
   if (template_url) {
     *is_omnibox_api_extension_keyword =
         template_url->type() == TemplateURL::OMNIBOX_API_EXTENSION;
     return template_url->AdjustedShortNameForLocaleDirection();
   }
   *is_omnibox_api_extension_keyword = false;
@@ skipping 564 matching lines @@
       if (i == 0)
         default_search_manager_.SetUserSelectedDefaultSearchEngine(data);
     }
   }
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine.
   RequestGoogleURLTrackerServerCheckIfNecessary();
 }
 
-TemplateURL* TemplateURLService::BestEngineForKeyword(TemplateURL* engine1,
-                                                      TemplateURL* engine2) {
+TemplateURL* TemplateURLService::BestEngineForKeyword(
+    TemplateURL* engine1,
+    TemplateURL* engine2) const {
   DCHECK(engine1);
   DCHECK(engine2);
   CHECK_NE(engine1, engine2);
   DCHECK_EQ(engine1->keyword(), engine2->keyword());
 
   std::string engine1_params = base::StringPrintf(
       "%s, %i, %" PRId64 ", %i, %s, %s",
       base::UTF16ToUTF8(engine1->keyword()).c_str(),
       static_cast<int>(engine1->type()), engine1->id(),
       engine1->prepopulate_id(), CanReplace(engine1) ? "true" : "false",
@@ skipping 182 matching lines @@
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 TemplateURLService::ChangeToLoadedState 3"));
 
   on_loaded_callbacks_.Notify();
 }
 
 bool TemplateURLService::CanAddAutogeneratedKeywordForHost(
-    const std::string& host) {
+    const std::string& host) const {
   const TemplateURLSet* urls = provider_map_->GetURLsForHost(host);
   if (!urls)
     return true;
   for (TemplateURLSet::const_iterator i(urls->begin()); i != urls->end(); ++i) {
     if (!(*i)->safe_for_autoreplace())
       return false;
   }
   return true;
 }
 
-bool TemplateURLService::CanReplace(const TemplateURL* t_url) {
+bool TemplateURLService::CanReplace(const TemplateURL* t_url) const {
   return !ShowInDefaultList(t_url) && t_url->safe_for_autoreplace();
 }
 
 TemplateURL* TemplateURLService::FindNonExtensionTemplateURLForKeyword(
-    const base::string16& keyword) {
+    const base::string16& keyword) const {
   TemplateURL* keyword_turl = GetTemplateURLForKeyword(keyword);
   if (!keyword_turl || (keyword_turl->type() == TemplateURL::NORMAL))
     return keyword_turl;
   // The extension keyword in the model may be hiding a replaceable
   // non-extension keyword.  Look for it.
   for (const auto& turl : template_urls_) {
     if ((turl->type() == TemplateURL::NORMAL) &&
         (turl->keyword() == keyword))
       return turl.get();
   }
@@ skipping 613 matching lines @@
   // This is a best-effort approach where we try to preserve the original
   // keyword and let the user do what they will after our attempt.
   base::string16 keyword_candidate(turl.keyword());
   do {
     keyword_candidate.append(base::ASCIIToUTF16("_"));
   } while (GetTemplateURLForKeyword(keyword_candidate));
 
   return keyword_candidate;
 }
 
-bool TemplateURLService::IsLocalTemplateURLBetter(const TemplateURL* local_turl,
-                                                  const TemplateURL* sync_turl,
-                                                  bool prefer_local_default) {
+bool TemplateURLService::IsLocalTemplateURLBetter(
+    const TemplateURL* local_turl,
+    const TemplateURL* sync_turl,
+    bool prefer_local_default) const {
   DCHECK(GetTemplateURLForGUID(local_turl->sync_guid()));
   return local_turl->last_modified() > sync_turl->last_modified() ||
          local_turl->created_by_policy() ||
          (prefer_local_default && local_turl == GetDefaultSearchProvider());
 }
 
 void TemplateURLService::ResolveSyncKeywordConflict(
     TemplateURL* unapplied_sync_turl,
     TemplateURL* applied_sync_turl,
     syncer::SyncChangeList* change_list) {
@@ skipping 193 matching lines @@
   // Add to vector of matching keywords.
   for (typename Container::const_iterator i(match_range.first);
     i != match_range.second; ++i) {
     if (!supports_replacement_only ||
         i->second.first->url_ref().SupportsReplacement(search_terms_data()))
       matches->push_back(i->second);
   }
 }
 
 TemplateURL* TemplateURLService::FindPrepopulatedTemplateURL(
-    int prepopulated_id) {
+    int prepopulated_id) const {
   for (const auto& turl : template_urls_) {
     if (turl->prepopulate_id() == prepopulated_id)
       return turl.get();
   }
   return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindTemplateURLForExtension(
     const std::string& extension_id,
-    TemplateURL::Type type) {
+    TemplateURL::Type type) const {
   DCHECK_NE(TemplateURL::NORMAL, type);
   for (const auto& turl : template_urls_) {
     if (turl->type() == type && turl->GetExtensionId() == extension_id)
       return turl.get();
   }
   return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindMatchingDefaultExtensionTemplateURL(
-    const TemplateURLData& data) {
+    const TemplateURLData& data) const {
   for (const auto& turl : template_urls_) {
     if (turl->type() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION &&
         turl->extension_info_->wants_to_be_default_engine &&
         TemplateURL::MatchesData(turl.get(), &data, search_terms_data()))
       return turl.get();
   }
   return nullptr;
 }
 
 bool TemplateURLService::HasDuplicateKeywords() const {
   std::map<base::string16, TemplateURL*> keyword_to_template_url;
   for (const auto& template_url : template_urls_) {
     // Validate no duplicate normal engines with same keyword.
     if (!IsCreatedByExtension(template_url.get())) {
       if (keyword_to_template_url.find(template_url->keyword()) !=
           keyword_to_template_url.end()) {
         return true;
       }
       keyword_to_template_url[template_url->keyword()] = template_url.get();
     }
   }
   return false;
 }