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

components/bookmarks/browser/bookmark_utils.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_utils.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 75 matching lines @@
   for (size_t i = 0; i < words.size(); ++i) {
     if (!base::i18n::StringSearchIgnoringCaseAndAccents(
             words[i], text, NULL, NULL)) {
       return false;
     }
   }
   return true;
 }
 
 // Returns true if |node|s title or url contains the strings in |words|.
-// |languages| argument is user's accept-language setting to decode IDN.
 bool DoesBookmarkContainWords(const BookmarkNode* node,
-                              const std::vector<base::string16>& words,
-                              const std::string& languages) {
+                              const std::vector<base::string16>& words) {
   return DoesBookmarkTextContainWords(node->GetTitle(), words) ||
          DoesBookmarkTextContainWords(base::UTF8ToUTF16(node->url().spec()),
                                       words) ||
          DoesBookmarkTextContainWords(
              url_formatter::FormatUrl(
-                 node->url(), languages, url_formatter::kFormatUrlOmitNothing,
+                 node->url(), url_formatter::kFormatUrlOmitNothing,
                  net::UnescapeRule::NORMAL, NULL, NULL, NULL),
              words);
 }
 
 // This is used with a tree iterator to skip subtrees which are not visible.
 bool PruneInvisibleFolders(const BookmarkNode* node) {
   return !node->IsVisible();
 }
 
 // This traces parents up to root, determines if node is contained in a
@@ skipping 68 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(VectorIterator);
 };
 
 template <class type>
 void GetBookmarksMatchingPropertiesImpl(
     type& iterator,
     BookmarkModel* model,
     const QueryFields& query,
     const std::vector<base::string16>& query_words,
     size_t max_count,
-    const std::string& languages,
     std::vector<const BookmarkNode*>* nodes) {
   while (iterator.has_next()) {
     const BookmarkNode* node = iterator.Next();
     if ((!query_words.empty() &&
-         !DoesBookmarkContainWords(node, query_words, languages)) ||
+         !DoesBookmarkContainWords(node, query_words)) ||
         model->is_permanent_node(node)) {
       continue;
     }
     if (query.title && node->GetTitle() != *query.title)
       continue;
 
     nodes->push_back(node);
     if (nodes->size() == max_count)
       return;
   }
@@ skipping 181 matching lines @@
   }
 }
 
 bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
   return n1->date_added() > n2->date_added();
 }
 
 void GetBookmarksMatchingProperties(BookmarkModel* model,
                                     const QueryFields& query,
                                     size_t max_count,
-                                    const std::string& languages,
                                     std::vector<const BookmarkNode*>* nodes) {
   std::vector<base::string16> query_words;
   query_parser::QueryParser parser;
   if (query.word_phrase_query) {
     parser.ParseQueryWords(base::i18n::ToLower(*query.word_phrase_query),
                            query_parser::MatchingAlgorithm::DEFAULT,
                            &query_words);
     if (query_words.empty())
       return;
   }
 
   if (query.url) {
     // Shortcut into the BookmarkModel if searching for URL.
     GURL url(*query.url);
     std::vector<const BookmarkNode*> url_matched_nodes;
     if (url.is_valid())
       model->GetNodesByURL(url, &url_matched_nodes);
     VectorIterator iterator(&url_matched_nodes);
     GetBookmarksMatchingPropertiesImpl<VectorIterator>(
-        iterator, model, query, query_words, max_count, languages, nodes);
+        iterator, model, query, query_words, max_count, nodes);
   } else {
     ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
     GetBookmarksMatchingPropertiesImpl<
         ui::TreeNodeIterator<const BookmarkNode>>(
-        iterator, model, query, query_words, max_count, languages, nodes);
+        iterator, model, query, query_words, max_count, nodes);
   }
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kShowBookmarkBar,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterBooleanPref(prefs::kEditBookmarksEnabled, true);
   registry->RegisterBooleanPref(
@@ skipping 77 matching lines @@
   for (size_t i = 0; i < bookmarks.size(); ++i) {
     const BookmarkNode* node = bookmarks[i];
     int index = node->parent()->GetIndexOf(node);
     if (index > -1 && model->client()->CanBeEditedByUser(node))
       model->Remove(node);
   }
 }
 
 base::string16 CleanUpUrlForMatching(
     const GURL& gurl,
-    const std::string& languages,
     base::OffsetAdjuster::Adjustments* adjustments) {
   base::OffsetAdjuster::Adjustments tmp_adjustments;
   return base::i18n::ToLower(url_formatter::FormatUrlWithAdjustments(
-      GURL(TruncateUrl(gurl.spec())), languages,
+      GURL(TruncateUrl(gurl.spec())),
       url_formatter::kFormatUrlOmitUsernamePassword,
       net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
           net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS,
       nullptr, nullptr, adjustments ? adjustments : &tmp_adjustments));
 }
 
 base::string16 CleanUpTitleForMatching(const base::string16& title) {
   return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
 }
 
@@ skipping 29 matching lines @@
 bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
                       const BookmarkNode* root) {
   for (const BookmarkNode* node : list) {
     if (IsDescendantOf(node, root))
       return true;
   }
   return false;
 }
 
 }  // namespace bookmarks