Support for searching bookmarks for IDN....

chrome/browser/bookmarks/bookmark_utils.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/bookmarks/bookmark_utils.h"
 
 #include "app/drag_drop_types.h"
 #include "app/l10n_util.h"
 // TODO(port): Port these files.
 #if defined(OS_WIN)
@@ skipping 11 matching lines @@
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/history/query_parser.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/page_navigator.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#include "net/base/net_util.h"
 #include "views/event.h"
 
 using base::Time;
 
 namespace {
 
 // A PageNavigator implementation that creates a new Browser. This is used when
 // opening a url and there is no Browser open. The Browser is created the first
 // time the PageNavigator method is invoked.
 class NewBrowserPageNavigator : public PageNavigator {
@@ skipping 128 matching lines @@
 bool DoesBookmarkTextContainWords(const std::wstring& text,
                                   const std::vector<std::wstring>& words) {
   for (size_t i = 0; i < words.size(); ++i) {
     if (text.find(words[i]) == std::wstring::npos)
       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(BookmarkNode* node,
-                              const std::vector<std::wstring>& words) {
+                              const std::vector<std::wstring>& words,
+                              const std::wstring& languages) {
   return
       DoesBookmarkTextContainWords(
           l10n_util::ToLower(node->GetTitle()), words) ||
-      DoesBookmarkTextContainWords(UTF8ToWide(node->GetURL().spec()), words);
+      DoesBookmarkTextContainWords(UTF8ToWide(node->GetURL().spec()), words) ||
+      DoesBookmarkTextContainWords(net::FormatUrl(
+          node->GetURL(), languages, false, true, NULL, NULL), words);
 }
 
 }  // namespace
 
 namespace bookmark_utils {
 
 int num_urls_before_prompting = 15;
 
 int PreferredDropOperation(int source_operations, int operations) {
   int common_ops = (source_operations & operations);
@@ skipping 275 matching lines @@
   }
 }
 
 bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2) {
   return n1->date_added() > n2->date_added();
 }
 
 void GetBookmarksContainingText(BookmarkModel* model,
                                 const std::wstring& text,
                                 size_t max_count,
+                                const std::wstring& languages,
                                 std::vector<BookmarkNode*>* nodes) {
   std::vector<std::wstring> words;
   QueryParser parser;
   parser.ExtractQueryWords(l10n_util::ToLower(text), &words);
   if (words.empty())
     return;
 
   TreeNodeIterator<BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
     BookmarkNode* node = iterator.Next();
-    if (node->is_url() && DoesBookmarkContainWords(node, words)) {
+    if (node->is_url() && DoesBookmarkContainWords(node, words, languages)) {
       nodes->push_back(node);
       if (nodes->size() == max_count)
         return;
     }
   }
 }
 
-bool DoesBookmarkContainText(BookmarkNode* node, const std::wstring& text) {
+bool DoesBookmarkContainText(BookmarkNode* node,
+                             const std::wstring& text,
+                             const std::wstring& languages) {
   std::vector<std::wstring> words;
   QueryParser parser;
   parser.ExtractQueryWords(l10n_util::ToLower(text), &words);
   if (words.empty())
     return false;
 
-  return (node->is_url() && DoesBookmarkContainWords(node, words));
+  return (node->is_url() && DoesBookmarkContainWords(node, words, languages));
 }
 
 void ApplyEditsWithNoGroupChange(BookmarkModel* model,
                                  BookmarkNode* parent,
                                  BookmarkNode* node,
                                  const std::wstring& new_title,
                                  const GURL& new_url,
                                  BookmarkEditor::Handler* handler) {
   BookmarkNode* old_parent = node ? node->GetParent() : NULL;
   const int old_index = old_parent ? old_parent->IndexOfChild(node) : -1;
@@ skipping 88 matching lines @@
 
   // Formerly in BookmarkTableView
   prefs->RegisterIntegerPref(prefs::kBookmarkTableNameWidth1, -1);
   prefs->RegisterIntegerPref(prefs::kBookmarkTableURLWidth1, -1);
   prefs->RegisterIntegerPref(prefs::kBookmarkTableNameWidth2, -1);
   prefs->RegisterIntegerPref(prefs::kBookmarkTableURLWidth2, -1);
   prefs->RegisterIntegerPref(prefs::kBookmarkTablePathWidth, -1);
 }
 
 }  // namespace bookmark_utils