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

components/bookmarks/browser/bookmark_index.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/bookmarks/browser/bookmark_index.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 18 matching lines @@
 typedef BookmarkClient::NodeTypedCountPair NodeTypedCountPair;
 typedef BookmarkClient::NodeTypedCountPairs NodeTypedCountPairs;
 
 namespace {
 
 // Returns a normalized version of the UTF16 string |text|.  If it fails to
 // normalize the string, returns |text| itself as a best-effort.
 base::string16 Normalize(const base::string16& text) {
   UErrorCode status = U_ZERO_ERROR;
   const icu::Normalizer2* normalizer2 =
-      icu::Normalizer2::getInstance(NULL, "nfkc", UNORM2_COMPOSE, status);
+      icu::Normalizer2::getInstance(nullptr, "nfkc", UNORM2_COMPOSE, status);
   if (U_FAILURE(status)) {
     // Log and crash right away to capture the error code in the crash report.
     LOG(FATAL) << "failed to create a normalizer: " << u_errorName(status);
   }
   icu::UnicodeString unicode_text(
       text.data(), static_cast<int32_t>(text.length()));
   icu::UnicodeString unicode_normalized_text;
   normalizer2->normalize(unicode_text, unicode_normalized_text, status);
   if (U_FAILURE(status)) {
     // This should not happen. Log the error and fall back.
@@ skipping 15 matching lines @@
 
 // Extract the const Node* stored in a BookmarkClient::NodeTypedCountPair.
 struct NodeTypedCountPairExtractNodeFunctor {
   const BookmarkNode* operator()(const NodeTypedCountPair& pair) const {
     return pair.first;
   }
 };
 
 }  // namespace
 
-BookmarkIndex::BookmarkIndex(BookmarkClient* client,
-                             const std::string& languages)
-    : client_(client),
-      languages_(languages) {
+BookmarkIndex::BookmarkIndex(BookmarkClient* client)
+    : client_(client) {
   DCHECK(client_);
 }
 
 BookmarkIndex::~BookmarkIndex() {
 }
 
 void BookmarkIndex::Add(const BookmarkNode* node) {
   if (!node->is_url())
     return;
   std::vector<base::string16> terms =
       ExtractQueryWords(Normalize(node->GetTitle()));
   for (size_t i = 0; i < terms.size(); ++i)
     RegisterNode(terms[i], node);
   terms =
-      ExtractQueryWords(CleanUpUrlForMatching(node->url(), languages_, NULL));
+      ExtractQueryWords(CleanUpUrlForMatching(node->url(), nullptr));
   for (size_t i = 0; i < terms.size(); ++i)
     RegisterNode(terms[i], node);
 }
 
 void BookmarkIndex::Remove(const BookmarkNode* node) {
   if (!node->is_url())
     return;
 
   std::vector<base::string16> terms =
       ExtractQueryWords(Normalize(node->GetTitle()));
   for (size_t i = 0; i < terms.size(); ++i)
     UnregisterNode(terms[i], node);
   terms =
-      ExtractQueryWords(CleanUpUrlForMatching(node->url(), languages_, NULL));
+      ExtractQueryWords(CleanUpUrlForMatching(node->url(), nullptr));
   for (size_t i = 0; i < terms.size(); ++i)
     UnregisterNode(terms[i], node);
 }
 
 void BookmarkIndex::GetBookmarksMatching(
     const base::string16& input_query,
     size_t max_count,
     query_parser::MatchingAlgorithm matching_algorithm,
     std::vector<BookmarkMatch>* results) {
   const base::string16 query = Normalize(input_query);
@@ skipping 57 matching lines @@
   // was a simple per-word search, while the more complex matching
   // of QueryParser may filter it out.  For example, the query
   // ["thi"] will match the bookmark titled [Thinking], but since
   // ["thi"] is quoted we don't want to do a prefix match.
   query_parser::QueryWordVector title_words, url_words;
   const base::string16 lower_title =
       base::i18n::ToLower(Normalize(node->GetTitle()));
   parser->ExtractQueryWords(lower_title, &title_words);
   base::OffsetAdjuster::Adjustments adjustments;
   parser->ExtractQueryWords(
-      CleanUpUrlForMatching(node->url(), languages_, &adjustments),
+      CleanUpUrlForMatching(node->url(), &adjustments),
       &url_words);
   query_parser::Snippet::MatchPositions title_matches, url_matches;
   for (size_t i = 0; i < query_nodes.size(); ++i) {
     const bool has_title_matches =
         query_nodes[i]->HasMatchIn(title_words, &title_matches);
     const bool has_url_matches =
         query_nodes[i]->HasMatchIn(url_words, &url_matches);
     if (!has_title_matches && !has_url_matches)
       return;
     query_parser::QueryParser::SortAndCoalesceMatchPositions(&title_matches);
@@ skipping 90 matching lines @@
     // We can get here if the node has the same term more than once. For
     // example, a bookmark with the title 'foo foo' would end up here.
     return;
   }
   i->second.erase(node);
   if (i->second.empty())
     index_.erase(i);
 }
 
 }  // namespace bookmarks