Omnibox: Make Keyword Provide More Generous with Matching

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 <list>
 #include <map>
 #include <set>
@@ skipping 54 matching lines @@
 // the Load method.
 //
 // TemplateURLService takes ownership of any TemplateURL passed to it. If there
 // is a KeywordWebDataService, deletion is handled by KeywordWebDataService,
 // otherwise TemplateURLService handles deletion.
 
 class TemplateURLService : public WebDataServiceConsumer,
                            public KeyedService,
                            public syncer::SyncableService {
  public:
-  typedef std::map<std::string, std::string> QueryTerms;
-  typedef std::vector<TemplateURL*> TemplateURLVector;
-  typedef std::map<std::string, syncer::SyncData> SyncDataMap;
-  typedef base::CallbackList<void(void)>::Subscription Subscription;
+  using QueryTerms = std::map<std::string, std::string>;
+  using TemplateURLVector = std::vector<TemplateURL*>;
+  using SyncDataMap = std::map<std::string, syncer::SyncData>;
+  using Subscription = base::CallbackList<void(void)>::Subscription;
+
+  // We may want to treat the keyword in a TemplateURL as being a different
+  // length than it actually is.  For example, for keywords that end in a
+  // registry, e.g., '.com', we want to consider the registry characters as not
+  // a meaningful part of the keyword and not penalize for the user not typing
+  // those.)
+  using TURLAndMeaningfulLength = std::pair<TemplateURL*, size_t>;
+  using TURLsAndMeaningfulLengths = std::vector<TURLAndMeaningfulLength>;
 
   // Struct used for initializing the data store with fake data.
   // Each initializer is mapped to a TemplateURL.
   struct Initializer {
     const char* const keyword;
     const char* const url;
     const char* const content;
   };
 
   struct URLVisitedDetails {
@@ skipping 24 matching lines @@
   // 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);
 
-  // Returns (in |matches|) all TemplateURLs whose keywords begin with |prefix|,
-  // sorted shortest keyword-first. If |support_replacement_only| is true, only
+  // 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 FindMatchingKeywords(const base::string16& prefix,
-                            bool support_replacement_only,
-                            TemplateURLVector* matches);
+  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);
 
   // 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.
@@ skipping 236 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
                            IsLocalTemplateURLBetter);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
                            ResolveSyncKeywordConflict);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, PreSyncDeletes);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, MergeInSyncTemplateURL);
 
   friend class InstantUnitTestBase;
   friend class TemplateURLServiceTestUtil;
 
-  typedef std::map<base::string16, TemplateURL*> KeywordToTemplateMap;
-  typedef std::map<std::string, TemplateURL*> GUIDToTemplateMap;
+  using GUIDToTURL = std::map<std::string, TemplateURL*>;
+
+  // A mapping from keywords to the corresponding TemplateURLs and their
+  // meaningful keyword lengths.  A keyword can appear only once here because
+  // there can be only one active TemplateURL associated with a given keyword.
+  using KeywordToTURLAndMeaningfulLength =
+      std::map<base::string16, TURLAndMeaningfulLength>;
+
+  // A mapping from domain names to corresponding TemplateURLs and their
+  // meaningful keyword lengths.  Specifically, for a keyword that is a
+  // hostname containing more than just a domain name, e.g., 'abc.def.com',
+  // the keyword is added to this map under the domain key 'def.com'.  This
+  // means multiple keywords from the same domain share the same key, so this
+  // must be a multimap.
+  using KeywordDomainToTURLAndMeaningfulLength =
+      std::multimap<base::string16, TURLAndMeaningfulLength>;
 
   // Declaration of values to be used in an enumerated histogram to tally
   // changes to the default search provider from various entry points. In
   // particular, we use this to see what proportion of changes are from Sync
   // entry points, to help spot erroneous Sync activity.
   enum DefaultSearchChangeOrigin {
     // Various known Sync entry points.
     DSP_CHANGE_SYNC_PREF,
     DSP_CHANGE_SYNC_ADD,
     DSP_CHANGE_SYNC_DELETE,
@@ skipping 16 matching lines @@
     // Boundary value.
     DSP_CHANGE_MAX,
   };
 
   // Helper functor for FindMatchingKeywords(), for finding the range of
   // keywords which begin with a prefix.
   class LessWithPrefix;
 
   void Init(const Initializer* initializers, int num_initializers);
 
+  // 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
+  // the keyword of a custom search engine already existing in the maps that
+  // is not allowed to be replaced.)
   void AddToMaps(TemplateURL* template_url);
 
+  // Helper function for removing an element from
+  // |keyword_domain_to_turl_and_length_|.
+  void RemoveFromDomainMap(const TemplateURL* template_url);
+
+  // Helper fuction for adding an element to
+  // |keyword_domain_to_turl_and_length_| if appropriate.
+  void AddToDomainMap(TemplateURL* template_url);
+
+  // Helper function for adding an element to |keyword_to_turl_and_length_|.
+  void AddToMap(TemplateURL* template_url);
+
   // Sets the keywords. This is used once the keywords have been loaded.
   // This does NOT notify the delegate or the database.
   //
   // This transfers ownership of the elements in |urls| to |this|, and may
   // delete some elements, so it's not safe for callers to access any elements
   // after calling; to reinforce this, this function clears |urls| on exit.
   void SetTemplateURLs(TemplateURLVector* urls);
 
   // Transitions to the loaded state.
   void ChangeToLoadedState();
@@ skipping 164 matching lines @@
   void OnSyncedDefaultSearchProviderGUIDChanged();
 
   // Adds |template_urls| to |template_urls_|.
   //
   // This transfers ownership of the elements in |template_urls| to |this|, and
   // may delete some elements, so it's not safe for callers to access any
   // elements after calling; to reinforce this, this function clears
   // |template_urls| on exit.
   void AddTemplateURLs(TemplateURLVector* template_urls);
 
+  // Adds to |matches| all TemplateURLs stored in |keyword_to_turl_and_length|
+  // whose keywords begin with |prefix|, sorted shortest-keyword-first.  If
+  // |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);
 
   // Returns the TemplateURL associated with |extension_id|, if any.
   TemplateURL* FindTemplateURLForExtension(const std::string& extension_id,
                                            TemplateURL::Type type);
 
   // Finds the extension-supplied TemplateURL that matches |data|, if any.
   TemplateURL* FindMatchingExtensionTemplateURL(const TemplateURLData& data,
                                                 TemplateURL::Type type);
@@ skipping 21 matching lines @@
   // ---------- Metrics related members ---------------------------------------
   rappor::RapporService* rappor_service_;
 
   // This closure is run when the default search provider is set to Google.
   base::Closure dsp_change_callback_;
 
 
   PrefChangeRegistrar pref_change_registrar_;
 
   // Mapping from keyword to the TemplateURL.
-  KeywordToTemplateMap keyword_to_template_map_;
+  KeywordToTURLAndMeaningfulLength keyword_to_turl_and_length_;
+
+  // Mapping from keyword domain to the TemplateURL.
+  // Entries are only allowed here if there is a corresponding entry in
+  // |keyword_to_turl_and_length_|, i.e., if a template URL doesn't have an
+  // entry in |keyword_to_turl_and_length_| because it's subsumed by another
+  // template URL with an identical keyword, the template URL will not have an
+  // entry in this map either.  This map will also not bother including entries
+  // for keywords in which the keyword is the domain name, with no subdomain
+  // before the domain name.  (The ordinary |keyword_to_turl_and_length|
+  // suffices for that.)
+  KeywordDomainToTURLAndMeaningfulLength keyword_domain_to_turl_and_length_;
 
   // Mapping from Sync GUIDs to the TemplateURL.
-  GUIDToTemplateMap guid_to_template_map_;
+  GUIDToTURL guid_to_turl_;
 
   TemplateURLVector template_urls_;
 
   base::ObserverList<TemplateURLServiceObserver> model_observers_;
 
   // Maps from host to set of TemplateURLs whose search url host is host.
   // NOTE: This is always non-NULL; we use a scoped_ptr<> to avoid circular
   // header dependencies.
   scoped_ptr<SearchHostToURLsMap> provider_map_;
 
@@ skipping 63 matching lines @@
 
   // Helper class to manage the default search engine.
   DefaultSearchManager default_search_manager_;
 
   scoped_ptr<GoogleURLTracker::Subscription> google_url_updated_subscription_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 
 #endif  // COMPONENTS_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_