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

components/omnibox/browser/url_index_private_data.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 "components/omnibox/browser/url_index_private_data.h"
 
 #include <stdint.h>
 
 #include <functional>
 #include <iterator>
@@ skipping 138 matching lines @@
       saved_cache_version_(kCurrentCacheFileVersion),
       pre_filter_item_count_(0),
       post_filter_item_count_(0),
       post_scoring_item_count_(0) {
 }
 
 ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
     base::string16 search_string,
     size_t cursor_position,
     size_t max_matches,
-    const std::string& languages,
     bookmarks::BookmarkModel* bookmark_model,
     TemplateURLService* template_url_service) {
   // If cursor position is set and useful (not at either end of the
   // string), allow the search string to be broken at cursor position.
   // We do this by pretending there's a space where the cursor is.
   if ((cursor_position != base::string16::npos) &&
       (cursor_position < search_string.length()) &&
       (cursor_position > 0)) {
     search_string.insert(cursor_position, base::ASCIIToUTF16(" "));
   }
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
   post_scoring_item_count_ = 0;
   // The search string we receive may contain escaped characters. For reducing
   // the index we need individual, lower-cased words, ignoring escapings. For
   // the final filtering we need whitespace separated substrings possibly
   // containing escaped characters.
   base::string16 lower_raw_string(base::i18n::ToLower(search_string));
   base::string16 lower_unescaped_string =
       net::UnescapeURLComponent(lower_raw_string,
           net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
           net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
   // Extract individual 'words' (as opposed to 'terms'; see below) from the
   // search string. When the user types "colspec=ID%20Mstone Release" we get
   // four 'words': "colspec", "id", "mstone" and "release".
   String16Vector lower_words(
-      String16VectorFromString16(lower_unescaped_string, false, NULL));
+      String16VectorFromString16(lower_unescaped_string, false, nullptr));
   ScoredHistoryMatches scored_items;
 
   // Do nothing if we have indexed no words (probably because we've not been
   // initialized yet) or the search string has no words.
   if (word_list_.empty() || lower_words.empty()) {
     search_term_cache_.clear();  // Invalidate the term cache.
     return scored_items;
   }
 
   // Reset used_ flags for search_term_cache_. We use a basic mark-and-sweep
@@ skipping 51 matching lines @@
     // excludes a long list of whitespace.)  One could write a scoring
     // function that gives a reasonable order to matches when there
     // are no terms (i.e., all the words are some form of whitespace),
     // but this is such a rare edge case that it's not worth the time.
     return scored_items;
   }
   scored_items =
       std::for_each(
           history_id_set.begin(), history_id_set.end(),
           AddHistoryMatch(bookmark_model, template_url_service, *this,
-                          languages, lower_raw_string, lower_raw_terms,
+                          lower_raw_string, lower_raw_terms,
                           base::Time::Now())).ScoredMatches();
 
   // Select and sort only the top |max_matches| results.
   if (scored_items.size() > max_matches) {
     std::partial_sort(scored_items.begin(),
                       scored_items.begin() +
                           max_matches,
                       scored_items.end(),
                       ScoredHistoryMatch::MatchScoreGreater);
       scored_items.resize(max_matches);
@@ skipping 15 matching lines @@
         ++cache_iter;
     }
   }
 
   return scored_items;
 }
 
 bool URLIndexPrivateData::UpdateURL(
     history::HistoryService* history_service,
     const history::URLRow& row,
-    const std::string& languages,
     const std::set<std::string>& scheme_whitelist,
     base::CancelableTaskTracker* tracker) {
   // The row may or may not already be in our index. If it is not already
   // indexed and it qualifies then it gets indexed. If it is already
   // indexed and still qualifies then it gets updated, otherwise it
   // is deleted from the index.
   bool row_was_updated = false;
   history::URLID row_id = row.id();
   HistoryInfoMap::iterator row_pos = history_info_map_.find(row_id);
   if (row_pos == history_info_map_.end()) {
     // This new row should be indexed if it qualifies.
     history::URLRow new_row(row);
     new_row.set_id(row_id);
     row_was_updated = RowQualifiesAsSignificant(new_row, base::Time()) &&
-                      IndexRow(NULL,
+                      IndexRow(nullptr,
                                history_service,
                                new_row,
-                               languages,
                                scheme_whitelist,
                                tracker);
   } else if (RowQualifiesAsSignificant(row, base::Time())) {
     // This indexed row still qualifies and will be re-indexed.
     // The url won't have changed but the title, visit count, etc.
     // might have changed.
     history::URLRow& row_to_update = row_pos->second.url_row;
     bool title_updated = row_to_update.title() != row.title();
     if (row_to_update.visit_count() != row.visit_count() ||
         row_to_update.typed_count() != row.typed_count() ||
         row_to_update.last_visit() != row.last_visit() || title_updated) {
       row_to_update.set_visit_count(row.visit_count());
       row_to_update.set_typed_count(row.typed_count());
       row_to_update.set_last_visit(row.last_visit());
       // If something appears to have changed, update the recent visits
       // information.
       ScheduleUpdateRecentVisits(history_service, row_id, tracker);
       // While the URL is guaranteed to remain stable, the title may have
       // changed. If so, then update the index with the changed words.
       if (title_updated) {
         // Clear all words associated with this row and re-index both the
         // URL and title.
         RemoveRowWordsFromIndex(row_to_update);
         row_to_update.set_title(row.title());
         RowWordStarts word_starts;
-        AddRowWordsToIndex(row_to_update, &word_starts, languages);
+        AddRowWordsToIndex(row_to_update, &word_starts);
         word_starts_map_[row_id] = word_starts;
       }
       row_was_updated = true;
     }
   } else {
     // This indexed row no longer qualifies and will be de-indexed by
     // clearing all words associated with this row.
     RemoveRowFromIndex(row);
     row_was_updated = true;
   }
@@ skipping 54 matching lines @@
       HistoryInfoMapItemHasURL(url));
   if (pos == history_info_map_.end())
     return false;
   RemoveRowFromIndex(pos->second.url_row);
   search_term_cache_.clear();  // This invalidates the cache.
   return true;
 }
 
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RestoreFromFile(
-    const base::FilePath& file_path,
-    const std::string& languages) {
+    const base::FilePath& file_path) {
   base::TimeTicks beginning_time = base::TimeTicks::Now();
   if (!base::PathExists(file_path))
-    return NULL;
+    return nullptr;
   std::string data;
   // If there is no cache file then simply give up. This will cause us to
   // attempt to rebuild from the history database.
   if (!base::ReadFileToString(file_path, &data))
-    return NULL;
+    return nullptr;
 
   scoped_refptr<URLIndexPrivateData> restored_data(new URLIndexPrivateData);
   InMemoryURLIndexCacheItem index_cache;
   if (!index_cache.ParseFromArray(data.c_str(), data.size())) {
     LOG(WARNING) << "Failed to parse URLIndexPrivateData cache data read from "
                  << file_path.value();
     return restored_data;
   }
 
-  if (!restored_data->RestorePrivateData(index_cache, languages))
-    return NULL;
+  if (!restored_data->RestorePrivateData(index_cache))
+    return nullptr;
 
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexRestoreCacheTime",
                       base::TimeTicks::Now() - beginning_time);
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLHistoryItems",
                        restored_data->history_id_word_map_.size());
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLCacheSize", data.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLWords",
                              restored_data->word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLChars",
                              restored_data->char_word_map_.size());
   if (restored_data->Empty())
-    return NULL;  // 'No data' is the same as a failed reload.
+    return nullptr;  // 'No data' is the same as a failed reload.
   return restored_data;
 }
 
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RebuildFromHistory(
     history::HistoryDatabase* history_db,
-    const std::string& languages,
     const std::set<std::string>& scheme_whitelist) {
   if (!history_db)
-    return NULL;
+    return nullptr;
 
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   scoped_refptr<URLIndexPrivateData>
       rebuilt_data(new URLIndexPrivateData);
   history::URLDatabase::URLEnumerator history_enum;
   if (!history_db->InitURLEnumeratorForSignificant(&history_enum))
-    return NULL;
+    return nullptr;
   rebuilt_data->last_time_rebuilt_from_history_ = base::Time::Now();
   for (history::URLRow row; history_enum.GetNextURL(&row);) {
     rebuilt_data->IndexRow(
-        history_db, NULL, row, languages, scheme_whitelist, NULL);
+        history_db, nullptr, row, scheme_whitelist, nullptr);
   }
 
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexingTime",
                       base::TimeTicks::Now() - beginning_time);
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLHistoryItems",
                        rebuilt_data->history_id_word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLWords",
                              rebuilt_data->word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLChars",
                              rebuilt_data->char_word_map_.size());
@@ skipping 217 matching lines @@
       word_id_set.swap(new_word_id_set);
     }
   }
   return word_id_set;
 }
 
 bool URLIndexPrivateData::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) {
   const GURL& gurl(row.url());
 
   // Index only URLs with a whitelisted scheme.
   if (!URLSchemeIsWhitelisted(gurl, scheme_whitelist))
     return false;
 
   history::URLID row_id = row.id();
   // Strip out username and password before saving and indexing.
   base::string16 url(url_formatter::FormatUrl(
-      gurl, languages, url_formatter::kFormatUrlOmitUsernamePassword,
+      gurl, url_formatter::kFormatUrlOmitUsernamePassword,
       net::UnescapeRule::NONE, nullptr, nullptr, nullptr));
 
   HistoryID history_id = static_cast<HistoryID>(row_id);
   DCHECK_LT(history_id, std::numeric_limits<HistoryID>::max());
 
   // Add the row for quick lookup in the history info store.
   history::URLRow new_row(GURL(url), row_id);
   new_row.set_visit_count(row.visit_count());
   new_row.set_typed_count(row.typed_count());
   new_row.set_last_visit(row.last_visit());
   new_row.set_title(row.title());
   history_info_map_[history_id].url_row = new_row;
 
   // Index the words contained in the URL and title of the row.
   RowWordStarts word_starts;
-  AddRowWordsToIndex(new_row, &word_starts, languages);
+  AddRowWordsToIndex(new_row, &word_starts);
   word_starts_map_[history_id] = word_starts;
 
   // Update the recent visits information or schedule the update
   // as appropriate.
   if (history_db) {
     // We'd like to check that we're on the history DB thread.
     // However, unittest code actually calls this on the UI thread.
     // So we don't do any thread checks.
     history::VisitVector recent_visits;
     // Make sure the private data is going to get as many recent visits as
     // ScoredHistoryMatch::GetFrequency() hopes to use.
     DCHECK_GE(kMaxVisitsToStoreInCache, ScoredHistoryMatch::kMaxVisitsToScore);
     if (history_db->GetMostRecentVisitsForURL(row_id,
                                               kMaxVisitsToStoreInCache,
                                               &recent_visits))
       UpdateRecentVisits(row_id, recent_visits);
   } else {
     DCHECK(tracker);
     DCHECK(history_service);
     ScheduleUpdateRecentVisits(history_service, row_id, tracker);
   }
 
   return true;
 }
 
 void URLIndexPrivateData::AddRowWordsToIndex(const history::URLRow& row,
-                                             RowWordStarts* word_starts,
-                                             const std::string& languages) {
+                                             RowWordStarts* word_starts) {
   HistoryID history_id = static_cast<HistoryID>(row.id());
   // Split URL into individual, unique words then add in the title words.
   const GURL& gurl(row.url());
   const base::string16& url =
-      bookmarks::CleanUpUrlForMatching(gurl, languages, NULL);
+      bookmarks::CleanUpUrlForMatching(gurl, nullptr);
   String16Set url_words = String16SetFromString16(url,
-      word_starts ? &word_starts->url_word_starts_ : NULL);
+      word_starts ? &word_starts->url_word_starts_ : nullptr);
   const base::string16& title = bookmarks::CleanUpTitleForMatching(row.title());
   String16Set title_words = String16SetFromString16(title,
-      word_starts ? &word_starts->title_word_starts_ : NULL);
+      word_starts ? &word_starts->title_word_starts_ : nullptr);
   String16Set words = base::STLSetUnion<String16Set>(url_words, title_words);
   for (String16Set::iterator word_iter = words.begin();
        word_iter != words.end(); ++word_iter)
     AddWordToIndex(*word_iter, history_id);
 
   search_term_cache_.clear();  // Invalidate the term cache.
 }
 
 void URLIndexPrivateData::AddWordToIndex(const base::string16& term,
                                          HistoryID history_id) {
@@ skipping 257 matching lines @@
     for (WordStarts::const_iterator i = word_starts.url_word_starts_.begin();
          i != word_starts.url_word_starts_.end(); ++i)
       map_entry->add_url_word_starts(*i);
     for (WordStarts::const_iterator i = word_starts.title_word_starts_.begin();
          i != word_starts.title_word_starts_.end(); ++i)
       map_entry->add_title_word_starts(*i);
   }
 }
 
 bool URLIndexPrivateData::RestorePrivateData(
-    const InMemoryURLIndexCacheItem& cache,
-    const std::string& languages) {
+    const InMemoryURLIndexCacheItem& cache) {
   last_time_rebuilt_from_history_ =
       base::Time::FromInternalValue(cache.last_rebuild_timestamp());
   const base::TimeDelta rebuilt_ago =
       base::Time::Now() - last_time_rebuilt_from_history_;
   if ((rebuilt_ago > base::TimeDelta::FromDays(7)) ||
       (rebuilt_ago < base::TimeDelta::FromDays(-1))) {
     // Cache is more than a week old or, somehow, from some time in the future.
     // It's probably a good time to rebuild the index from history to
     // allow synced entries to now appear, expired entries to disappear, etc.
     // Allow one day in the future to make the cache not rebuild on simple
     // system clock changes such as time zone changes.
     return false;
   }
   if (cache.has_version()) {
     if (cache.version() < kCurrentCacheFileVersion) {
       // Don't try to restore an old format cache file.  (This will cause
       // the InMemoryURLIndex to schedule rebuilding the URLIndexPrivateData
       // from history.)
       return false;
     }
     restored_cache_version_ = cache.version();
   }
   return RestoreWordList(cache) && RestoreWordMap(cache) &&
       RestoreCharWordMap(cache) && RestoreWordIDHistoryMap(cache) &&
-      RestoreHistoryInfoMap(cache) && RestoreWordStartsMap(cache, languages);
+      RestoreHistoryInfoMap(cache) && RestoreWordStartsMap(cache);
 }
 
 bool URLIndexPrivateData::RestoreWordList(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_word_list())
     return false;
   const WordListItem& list_item(cache.word_list());
   uint32_t expected_item_count = list_item.word_count();
   uint32_t actual_item_count = list_item.word_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
@@ skipping 111 matching lines @@
       visits.push_back(std::make_pair(
           base::Time::FromInternalValue(iter->visits(i).visit_time()),
           ui::PageTransitionFromInt(iter->visits(i).transition_type())));
     }
     history_info_map_[history_id].visits = visits;
   }
   return true;
 }
 
 bool URLIndexPrivateData::RestoreWordStartsMap(
-    const InMemoryURLIndexCacheItem& cache,
-    const std::string& languages) {
+    const InMemoryURLIndexCacheItem& cache) {
   // Note that this function must be called after RestoreHistoryInfoMap() has
   // been run as the word starts may have to be recalculated from the urls and
   // page titles.
   if (cache.has_word_starts_map()) {
     const WordStartsMapItem& list_item(cache.word_starts_map());
     uint32_t expected_item_count = list_item.item_count();
     uint32_t actual_item_count = list_item.word_starts_map_entry_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     const RepeatedPtrField<WordStartsMapEntry>&
@@ skipping 15 matching lines @@
       word_starts_map_[history_id] = word_starts;
     }
   } else {
     // Since the cache did not contain any word starts we must rebuild then from
     // the URL and page titles.
     for (HistoryInfoMap::const_iterator iter = history_info_map_.begin();
          iter != history_info_map_.end(); ++iter) {
       RowWordStarts word_starts;
       const history::URLRow& row(iter->second.url_row);
       const base::string16& url =
-          bookmarks::CleanUpUrlForMatching(row.url(), languages, NULL);
+          bookmarks::CleanUpUrlForMatching(row.url(), nullptr);
       String16VectorFromString16(url, false, &word_starts.url_word_starts_);
       const base::string16& title =
           bookmarks::CleanUpTitleForMatching(row.title());
       String16VectorFromString16(title, false, &word_starts.title_word_starts_);
       word_starts_map_[iter->first] = word_starts;
     }
   }
   return true;
 }
 
@@ skipping 21 matching lines @@
 
 URLIndexPrivateData::SearchTermCacheItem::~SearchTermCacheItem() {
 }
 
 // URLIndexPrivateData::AddHistoryMatch ----------------------------------------
 
 URLIndexPrivateData::AddHistoryMatch::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)
     : bookmark_model_(bookmark_model),
       template_url_service_(template_url_service),
       private_data_(private_data),
-      languages_(languages),
       lower_string_(lower_string),
       lower_terms_(lower_terms),
       now_(now) {
   // Calculate offsets for each term.  For instance, the offset for
   // ".net" should be 1, indicating that the actual word-part of the term
   // starts at offset 1.
   lower_terms_to_word_starts_offsets_.resize(lower_terms_.size(), 0u);
   for (size_t i = 0; i < lower_terms_.size(); ++i) {
     base::i18n::BreakIterator iter(lower_terms_[i],
                                    base::i18n::BreakIterator::BREAK_WORD);
@@ skipping 19 matching lines @@
     const HistoryID history_id) {
   HistoryInfoMap::const_iterator hist_pos =
       private_data_.history_info_map_.find(history_id);
   if (hist_pos != private_data_.history_info_map_.end()) {
     const history::URLRow& hist_item = hist_pos->second.url_row;
     const VisitInfoVector& visits = hist_pos->second.visits;
     WordStartsMap::const_iterator starts_pos =
         private_data_.word_starts_map_.find(history_id);
     DCHECK(starts_pos != private_data_.word_starts_map_.end());
     ScoredHistoryMatch match(
-        hist_item, visits, languages_, lower_string_, lower_terms_,
+        hist_item, visits, lower_string_, lower_terms_,
         lower_terms_to_word_starts_offsets_, starts_pos->second,
         bookmark_model_ && bookmark_model_->IsBookmarked(hist_item.url()),
         template_url_service_, now_);
     if (match.raw_score > 0)
       scored_matches_.push_back(match);
   }
 }
 
 
 // URLIndexPrivateData::HistoryItemFactorGreater -------------------------------
@@ skipping 20 matching lines @@
   // First cut: typed count, visit count, recency.
   // TODO(mrossetti): This is too simplistic. Consider an approach which ranks
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }