Make several methods of TemplateUrlService const

components/search_engines/template_url_service.h

 // 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.
 
 #ifndef COMPONENTS_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 #define COMPONENTS_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 113 matching lines @@
 
   // Returns true if there is no TemplateURL that conflicts with the
   // keyword/url pair, or there is one but it can be replaced. If there is an
   // existing keyword that can be replaced and template_url_to_replace is
   // non-NULL, template_url_to_replace is set to the keyword to replace.
   //
   // |url| is the URL of the search query.  This is used to prevent auto-adding
   // a keyword for hosts already associated with a manually-edited keyword.
   bool CanAddAutogeneratedKeyword(const base::string16& keyword,
                                   const GURL& url,
-                                  TemplateURL** template_url_to_replace);
+                                  TemplateURL** template_url_to_replace) const;
 
   // Returns whether the engine is a "pre-existing" engine, either from the
   // prepopulate list or created by policy.
-  bool IsPrepopulatedOrCreatedByPolicy(const TemplateURL* template_url);
+  bool IsPrepopulatedOrCreatedByPolicy(const TemplateURL* template_url) const;
 
   // Returns whether |template_url| should be shown in the list of engines
   // most likely to be selected as a default engine. This is meant to highlight
   // the current default, as well as the other most likely choices of default
   // engine, separately from a full list of all TemplateURLs (which might be
   // very long).
-  bool ShowInDefaultList(const TemplateURL* template_url);
+  bool ShowInDefaultList(const TemplateURL* template_url) const;
 
   // Adds to |matches| all TemplateURLs whose keywords begin with |prefix|,
   // sorted shortest-keyword-first. If |supports_replacement_only| is true, only
   // TemplateURLs that support replacement are returned.
   void AddMatchingKeywords(const base::string16& prefix,
                            bool supports_replacement_only,
                            TURLsAndMeaningfulLengths* matches);
 
   // Adds to |matches| all TemplateURLs for search engines with the domain
   // name part of the keyword starts with |prefix|, sorted
   // shortest-domain-name-first. If |supports_replacement_only| is true, only
   // TemplateURLs that support replacement are returned.  Does not bother
   // searching/returning keywords that would've been found with an identical
   // call to FindMatchingKeywords(); i.e., doesn't search keywords for which
   // the domain name is the keyword.
   void AddMatchingDomainKeywords(const base::string16& prefix,
                                  bool supports_replacement_only,
                                  TURLsAndMeaningfulLengths* matches);
 
   // Looks up |keyword| and returns the element it maps to.  Returns NULL if
   // the keyword was not found.
   // The caller should not try to delete the returned pointer; the data store
   // retains ownership of it.
-  TemplateURL* GetTemplateURLForKeyword(const base::string16& keyword);
+  TemplateURL* GetTemplateURLForKeyword(const base::string16& keyword) const;

[Peter Kasting, 2017/04/13 04:04:52]

Const methods shouldn't return non-const pointers, so either these next three
need to remain non-const, or return pointers-to-const, or we need const and
non-const versions.

The same is true of the other methods below that return TemplateURL*s.

 
   // Returns that TemplateURL with the specified GUID, or NULL if not found.
   // The caller should not try to delete the returned pointer; the data store
   // retains ownership of it.
-  TemplateURL* GetTemplateURLForGUID(const std::string& sync_guid);
+  TemplateURL* GetTemplateURLForGUID(const std::string& sync_guid) const;
 
   // Returns the first TemplateURL found with a URL using the specified |host|,
   // or NULL if there are no such TemplateURLs
-  TemplateURL* GetTemplateURLForHost(const std::string& host);
+  TemplateURL* GetTemplateURLForHost(const std::string& host) const;
 
   // Adds |template_url| to this model.  Returns a raw pointer to |template_url|
   // if the addition succeeded, or null on failure.  (Many callers need still
   // need a raw pointer to the TemplateURL so they can access it later.)
   TemplateURL* Add(std::unique_ptr<TemplateURL> template_url);
 
   // Like Add(), but overwrites the |template_url|'s values with the provided
   // ones.
   TemplateURL* AddWithOverrides(std::unique_ptr<TemplateURL> template_url,
                                 const base::string16& short_name,
@@ skipping 52 matching lines @@
   // Resets the title, keyword and search url of the specified TemplateURL.
   // The TemplateURL is marked as not replaceable.
   void ResetTemplateURL(TemplateURL* url,
                         const base::string16& title,
                         const base::string16& keyword,
                         const std::string& search_url);
 
   // Return true if the given |url| can be made the default. This returns false
   // regardless of |url| if the default search provider is managed by policy or
   // controlled by an extension.
-  bool CanMakeDefault(const TemplateURL* url);
+  bool CanMakeDefault(const TemplateURL* url) const;
 
   // Set the default search provider.  |url| may be null.
   // This will assert if the default search is managed; the UI should not be
   // invoking this method in that situation.
   void SetUserSelectedDefaultSearchProvider(TemplateURL* url);
 
   // Returns the default search provider. If the TemplateURLService hasn't been
   // loaded, the default search provider is pulled from preferences.
   //
   // NOTE: At least in unittest mode, this may return NULL.
   // TODO(blundell): See if all callers can be converted to take in const
   // pointers and eliminate this version of the method.
   TemplateURL* GetDefaultSearchProvider();
   const TemplateURL* GetDefaultSearchProvider() const;
 
   // Returns true if the |url| is a search results page from the default search
   // provider.
   bool IsSearchResultsPageFromDefaultSearchProvider(const GURL& url) const;
 
   // Returns true if the default search is managed through group policy.
   bool is_default_search_managed() const {
     return default_search_provider_source_ == DefaultSearchManager::FROM_POLICY;
   }
 
   // Returns true if the default search provider is controlled by an extension.
-  bool IsExtensionControlledDefaultSearch();
+  bool IsExtensionControlledDefaultSearch() const;
 
   // Returns the default search specified in the prepopulated data, if it
   // exists.  If not, returns first URL in |template_urls_|, or NULL if that's
   // empty. The returned object is owned by TemplateURLService and can be
   // destroyed at any time so should be used right after the call.
   TemplateURL* FindNewDefaultSearchProvider();
 
   // Performs the same actions that happen when the prepopulate data version is
   // revved: all existing prepopulated entries are checked against the current
   // prepopulate data, any now-extraneous safe_for_autoreplace() entries are
@@ skipping 35 matching lines @@
   // Notification that the keywords have been loaded.
   // This is invoked from WebDataService, and should not be directly
   // invoked.
   void OnWebDataServiceRequestDone(
       KeywordWebDataService::Handle h,
       std::unique_ptr<WDTypedResult> result) override;
 
   // Returns the locale-direction-adjusted short name for the given keyword.
   // Also sets the out param to indicate whether the keyword belongs to an
   // Omnibox extension.
-  base::string16 GetKeywordShortName(const base::string16& keyword,
-                                     bool* is_omnibox_api_extension_keyword);
+  base::string16 GetKeywordShortName(
+      const base::string16& keyword,
+      bool* is_omnibox_api_extension_keyword) const;
 
   // Called by the history service when a URL is visited.
   void OnHistoryURLVisited(const URLVisitedDetails& details);
 
   // KeyedService implementation.
   void Shutdown() override;
 
   // syncer::SyncableService implementation.
 
   // Returns all syncable TemplateURLs from this model as SyncData. This should
@@ skipping 141 matching lines @@
 
   void Init(const Initializer* initializers, int num_initializers);
 
   // Given two engines with the same keyword, returns which should take
   // precedence.  While normal engines must all have distinct keywords,
   // extension-controlled and omnibox API engines may have the same keywords as
   // each other or as normal engines.  In these cases, omnibox API engines
   // override extension-controlled engines, which override normal engines; if
   // there is still a conflict after this, the most recently-added extension
   // wins.
-  TemplateURL* BestEngineForKeyword(TemplateURL* engine1, TemplateURL* engine2);
+  TemplateURL* BestEngineForKeyword(TemplateURL* engine1,
+                                    TemplateURL* engine2) const;
 
   // Removes |template_url| from various internal maps
   // (|keyword_to_turl_and_length_|, |keyword_domain_to_turl_and_length_|,
   // |guid_to_turl_|, |provider_map_|).
   void RemoveFromMaps(TemplateURL* template_url);
 
   // Adds |template_url| to various internal maps
   // (|keyword_to_turl_and_length_|, |keyword_domain_to_turl_and_length_|,
   // |guid_to_turl_|, |provider_map_|) if appropriate.  (It might not be
   // appropriate if, for instance, |template_url|'s keyword conflicts with
@@ skipping 29 matching lines @@
                                 DefaultSearchManager::Source source);
 
 
   // Applies a DSE change. May be called at startup or after transitioning to
   // the loaded state. Returns true if a change actually occurred.
   bool ApplyDefaultSearchChangeNoMetrics(const TemplateURLData* new_dse_data,
                                          DefaultSearchManager::Source source);
 
   // Returns false if there is a TemplateURL that has a search url with the
   // specified host and that TemplateURL has been manually modified.
-  bool CanAddAutogeneratedKeywordForHost(const std::string& host);
+  bool CanAddAutogeneratedKeywordForHost(const std::string& host) const;
 
   // Returns true if the TemplateURL is replaceable. This doesn't look at the
   // uniqueness of the keyword or host and is intended to be called after those
   // checks have been done. This returns true if the TemplateURL doesn't appear
   // in the default list and is marked as safe_for_autoreplace.
-  bool CanReplace(const TemplateURL* t_url);
+  bool CanReplace(const TemplateURL* t_url) const;
 
   // Like GetTemplateURLForKeyword(), but ignores extension-provided keywords.
   TemplateURL* FindNonExtensionTemplateURLForKeyword(
-      const base::string16& keyword);
+      const base::string16& keyword) const;
 
   // Updates the information in |existing_turl| using the information from
   // |new_values|, but the ID for |existing_turl| is retained.  Notifying
   // observers is the responsibility of the caller.  Returns whether
   // |existing_turl| was found in |template_urls_| and thus could be updated.
   //
   // NOTE: This should not be called with an extension keyword as there are no
   // updates needed in that case.
   bool UpdateNoNotify(TemplateURL* existing_turl,
                       const TemplateURL& new_values);
@@ skipping 87 matching lines @@
   // known to the local model (though it may already be synced), and |sync_turl|
   // is a new TemplateURL known to Sync but not yet known to the local model.
   // The criteria for if |local_turl| is better than |sync_turl| is whether any
   // of the following are true:
   //  * |local_turl|'s last_modified timestamp is newer than sync_turl.
   //  * |local_turl| is created by policy.
   //  * |prefer_local_default| is true and |local_turl| is the local default
   //    search provider
   bool IsLocalTemplateURLBetter(const TemplateURL* local_turl,
                                 const TemplateURL* sync_turl,
-                                bool prefer_local_default = true);
+                                bool prefer_local_default = true) const;
 
   // Given two synced TemplateURLs with a conflicting keyword, one of which
   // needs to be added to or updated in the local model (|unapplied_sync_turl|)
   // and one which is already known to the local model (|applied_sync_turl|),
   // prepares the local model so that |unapplied_sync_turl| can be added to it,
   // or applied as an update to an existing TemplateURL.
   // Since both entries are known to Sync and one of their keywords will change,
   // an ACTION_UPDATE will be appended to |change_list| to reflect this change.
   // Note that |applied_sync_turl| must not be an extension keyword.
   void ResolveSyncKeywordConflict(TemplateURL* unapplied_sync_turl,
@@ skipping 32 matching lines @@
   // |supports_replacement_only| is true, only TemplateURLs that support
   // replacement are returned.
   template <typename Container>
   void AddMatchingKeywordsHelper(
       const Container& keyword_to_turl_and_length,
       const base::string16& prefix,
       bool supports_replacement_only,
       TURLsAndMeaningfulLengths* matches);
 
   // Returns the TemplateURL corresponding to |prepopulated_id|, if any.
-  TemplateURL* FindPrepopulatedTemplateURL(int prepopulated_id);
+  TemplateURL* FindPrepopulatedTemplateURL(int prepopulated_id) const;
 
   // Returns the TemplateURL associated with |extension_id|, if any.
   TemplateURL* FindTemplateURLForExtension(const std::string& extension_id,
-                                           TemplateURL::Type type);
+                                           TemplateURL::Type type) const;
 
   // Finds any NORMAL_CONTROLLED_BY_EXTENSION engine that matches |data| and
   // wants to be default. Returns nullptr if not found.
   TemplateURL* FindMatchingDefaultExtensionTemplateURL(
-      const TemplateURLData& data);
+      const TemplateURLData& data) const;
 
   // Returns whether |template_urls_| contains more than one normal engine with
   // same keyword. Used to validate state after search engines are
   // added/updated.
   bool HasDuplicateKeywords() const;
 
   // ---------- Browser state related members ---------------------------------
   PrefService* prefs_;
 
   std::unique_ptr<SearchTermsData> search_terms_data_;
@@ skipping 111 matching lines @@
   // Helper class to manage the default search engine.
   DefaultSearchManager default_search_manager_;
 
   std::unique_ptr<GoogleURLTracker::Subscription>
       google_url_updated_subscription_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 
 #endif  // COMPONENTS_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_