Drop |languages| from {Format,Elide}Url* and IDNToUnicode

components/omnibox/browser/url_index_private_data.h

 // 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.
 
 #ifndef COMPONENTS_OMNIBOX_BROWSER_URL_INDEX_PRIVATE_DATA_H_
 #define COMPONENTS_OMNIBOX_BROWSER_URL_INDEX_PRIVATE_DATA_H_
 
 #include <stddef.h>
 
 #include <set>
@@ skipping 48 matching lines @@
   // set). Once we have a set of candidates, they are filtered to ensure
   // that all |term_string| terms, as separated by whitespace and the
   // cursor (if set), occur within the candidate's URL or page title.
   // Scores are then calculated on no more than |kItemsToScoreLimit|
   // candidates, as the scoring of such a large number of candidates may
   // cause perceptible typing response delays in the omnibox. This is
   // likely to occur for short omnibox terms such as 'h' and 'w' which
   // will be found in nearly all history candidates. Results are sorted by
   // descending score. The full results set (i.e. beyond the
   // |kItemsToScoreLimit| limit) will be retained and used for subsequent calls
-  // to this function. |languages| is used to help parse/format the URLs in the
-  // history index.  In total, |max_matches| of items will be returned in the
+  // to this function. In total, |max_matches| of items will be returned in the
   // |ScoredHistoryMatches| vector.
   ScoredHistoryMatches HistoryItemsForTerms(
       base::string16 term_string,
       size_t cursor_position,
       size_t max_matches,
-      const std::string& languages,
       bookmarks::BookmarkModel* bookmark_model,
       TemplateURLService* template_url_service);
 
   // Adds the history item in |row| to the index if it does not already already
   // exist and it meets the minimum 'quick' criteria. If the row already exists
   // in the index then the index will be updated if the row still meets the
   // criteria, otherwise the row will be removed from the index. Returns true
-  // if the index was actually updated. |languages| gives a list of language
-  // encodings by which the URLs and page titles are broken down into words and
-  // characters. |scheme_whitelist| is used to filter non-qualifying schemes.
-  // |history_service| is used to schedule an update to the recent visits
-  // component of this URL's entry in the index.
+  // if the index was actually updated. |scheme_whitelist| is used to filter
+  // non-qualifying schemes. |history_service| is used to schedule an update to
+  // the recent visits component of this URL's entry in the index.
   bool UpdateURL(history::HistoryService* history_service,
                  const history::URLRow& row,
-                 const std::string& languages,
                  const std::set<std::string>& scheme_whitelist,
                  base::CancelableTaskTracker* tracker);
 
   // Updates the entry for |url_id| in the index, replacing its
   // recent visits information with |recent_visits|.  If |url_id|
   // is not in the index, does nothing.
   void UpdateRecentVisits(history::URLID url_id,
                           const history::VisitVector& recent_visits);
 
   // Using |history_service| schedules an update (using the historyDB
   // thread) for the recent visits information for |url_id|.  Unless
   // something unexpectedly goes wrong, UdpateRecentVisits() should
   // eventually be called from a callback.
   void ScheduleUpdateRecentVisits(history::HistoryService* history_service,
                                   history::URLID url_id,
                                   base::CancelableTaskTracker* tracker);
 
   // Deletes index data for the history item with the given |url|.
   // The item may not have actually been indexed, which is the case if it did
   // not previously meet minimum 'quick' criteria. Returns true if the index
   // was actually updated.
   bool DeleteURL(const GURL& url);
 
   // Constructs a new object by restoring its contents from the cache file
   // at |path|. Returns the new URLIndexPrivateData which on success will
-  // contain the restored data but upon failure will be empty.  |languages|
-  // is used to break URLs and page titles into words.  This function
-  // should be run on the the file thread.
+  // contain the restored data but upon failure will be empty.
+  // This function should be run on the the file thread.
   static scoped_refptr<URLIndexPrivateData> RestoreFromFile(
-      const base::FilePath& path,
-      const std::string& languages);
+      const base::FilePath& path);
 
   // Constructs a new object by rebuilding its contents from the history
   // database in |history_db|. Returns the new URLIndexPrivateData which on
   // success will contain the rebuilt data but upon failure will be empty.
-  // |languages| gives a list of language encodings by which the URLs and page
-  // titles are broken down into words and characters.
   static scoped_refptr<URLIndexPrivateData> RebuildFromHistory(
       history::HistoryDatabase* history_db,
-      const std::string& languages,
       const std::set<std::string>& scheme_whitelist);
 
   // Writes |private_data| as a cache file to |file_path| and returns success.
   static bool WritePrivateDataToCacheFileTask(
       scoped_refptr<URLIndexPrivateData> private_data,
       const base::FilePath& file_path);
 
   // Creates a copy of ourself.
   scoped_refptr<URLIndexPrivateData> Duplicate() const;
 
@@ skipping 54 matching lines @@
   };
   typedef std::map<base::string16, SearchTermCacheItem> SearchTermCacheMap;
 
   // A helper class which performs the final filter on each candidate
   // history URL match, inserting accepted matches into |scored_matches_|.
   class AddHistoryMatch {
    public:
     AddHistoryMatch(bookmarks::BookmarkModel* bookmark_model,
                     TemplateURLService* template_url_service,
                     const URLIndexPrivateData& private_data,
-                    const std::string& languages,
                     const base::string16& lower_string,
                     const String16Vector& lower_terms,
                     const base::Time now);
     AddHistoryMatch(const AddHistoryMatch& other);
     ~AddHistoryMatch();
 
     void operator()(const HistoryID history_id);
 
     ScoredHistoryMatches ScoredMatches() const { return scored_matches_; }
 
    private:
     friend class InMemoryURLIndexTest;
     FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, AddHistoryMatch);
     bookmarks::BookmarkModel* bookmark_model_;
     TemplateURLService* template_url_service_;
     const URLIndexPrivateData& private_data_;
-    const std::string& languages_;
     ScoredHistoryMatches scored_matches_;
     const base::string16& lower_string_;
     const String16Vector& lower_terms_;
     WordStarts lower_terms_to_word_starts_offsets_;
     const base::Time now_;
   };
 
   // A helper predicate class used to filter excess history items when the
   // candidate results set is too large.
   class HistoryItemFactorGreater {
@@ skipping 14 matching lines @@
   HistoryIDSet HistoryIDSetFromWords(const String16Vector& unsorted_words);
 
   // Helper function to HistoryIDSetFromWords which composes a set of history
   // ids for the given term given in |term|.
   HistoryIDSet HistoryIDsForTerm(const base::string16& term);
 
   // Given a set of Char16s, finds words containing those characters.
   WordIDSet WordIDSetForTermChars(const Char16Set& term_chars);
 
   // Indexes one URL history item as described by |row|. Returns true if the
-  // row was actually indexed. |languages| gives a list of language encodings by
-  // which the URLs and page titles are broken down into words and characters.
-  // |scheme_whitelist| is used to filter non-qualifying schemes.  If
-  // |history_db| is not NULL then this function uses the history database
-  // synchronously to get the URL's recent visits information.  This mode should
-  // only be used on the historyDB thread.  If |history_db| is NULL, then
-  // this function uses |history_service| to schedule a task on the
-  // historyDB thread to fetch and update the recent visits
-  // information.
+  // row was actually indexed. |scheme_whitelist| is used to filter
+  // non-qualifying schemes.  If |history_db| is not NULL then this function
+  // uses the history database synchronously to get the URL's recent visits
+  // information.  This mode should/ only be used on the historyDB thread.
+  // If |history_db| is NULL, then this function uses |history_service| to
+  // schedule a task on the historyDB thread to fetch and update the recent
+  // visits information.
   bool IndexRow(history::HistoryDatabase* history_db,
                 history::HistoryService* history_service,
                 const history::URLRow& row,
-                const std::string& languages,
                 const std::set<std::string>& scheme_whitelist,
                 base::CancelableTaskTracker* tracker);
 
   // Parses and indexes the words in the URL and page title of |row| and
   // calculate the word starts in each, saving the starts in |word_starts|.
-  // |languages| gives a list of language encodings by which the URLs and page
-  // titles are broken down into words and characters.
   void AddRowWordsToIndex(const history::URLRow& row,
-                          RowWordStarts* word_starts,
-                          const std::string& languages);
+                          RowWordStarts* word_starts);
 
   // Given a single word in |uni_word|, adds a reference for the containing
   // history item identified by |history_id| to the index.
   void AddWordToIndex(const base::string16& uni_word, HistoryID history_id);
 
   // Creates a new entry in the word/history map for |word_id| and add
   // |history_id| as the initial element of the word's set.
   void AddWordHistory(const base::string16& uni_word, HistoryID history_id);
 
   // Updates an existing entry in the word/history index by adding the
@@ skipping 26 matching lines @@
   void SaveCharWordMap(
       in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordIDHistoryMap(
       in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
   void SaveHistoryInfoMap(
       in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordStartsMap(
       in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
 
   // Decode a data structure from the protobuf |cache|. Return false if there
-  // is any kind of failure. |languages| will be used to break URLs and page
-  // titles into words
+  // is any kind of failure.
   bool RestorePrivateData(
-      const in_memory_url_index::InMemoryURLIndexCacheItem& cache,
-      const std::string& languages);
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordList(
       const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordMap(
       const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreCharWordMap(
       const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordIDHistoryMap(
       const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreHistoryInfoMap(
       const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordStartsMap(
-      const in_memory_url_index::InMemoryURLIndexCacheItem& cache,
-      const std::string& languages);
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
 
   // Determines if |gurl| has a whitelisted scheme and returns true if so.
   static bool URLSchemeIsWhitelisted(const GURL& gurl,
                                      const std::set<std::string>& whitelist);
 
   // Cache of search terms.
   SearchTermCacheMap search_term_cache_;
 
   // Start of data members that are cached -------------------------------------
 
@@ skipping 53 matching lines @@
   int saved_cache_version_;
 
   // Used for unit testing only. Records the number of candidate history items
   // at three stages in the index searching process.
   size_t pre_filter_item_count_;    // After word index is queried.
   size_t post_filter_item_count_;   // After trimming large result set.
   size_t post_scoring_item_count_;  // After performing final filter/scoring.
 };
 
 #endif  // COMPONENTS_OMNIBOX_BROWSER_URL_INDEX_PRIVATE_DATA_H_