src/chrome/browser/bookmarks/bookmark_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/bookmarks/bookmark_utils.h"
   6
   7 #include <utility>
   8
   9 #include "base/basictypes.h"
  10 #include "base/files/file_path.h"
  11 #include "base/i18n/case_conversion.h"
  12 #include "base/i18n/string_search.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/strings/string16.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/time/time.h"
  17 #include "chrome/browser/bookmarks/bookmark_model.h"
  18 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  19 #include "chrome/browser/history/query_parser.h"
  20 #include "chrome/browser/undo/bookmark_undo_service.h"
  21 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "components/user_prefs/pref_registry_syncable.h"
  24 #include "content/public/browser/user_metrics.h"
  25 #include "net/base/net_util.h"
  26 #include "ui/base/models/tree_node_iterator.h"
  27
  28 #if !defined(OS_ANDROID)
  29 #include "chrome/browser/bookmarks/scoped_group_bookmark_actions.h"
  30 #endif
  31
  32 using base::Time;
  33
  34 namespace {
  35
  36 void CloneBookmarkNodeImpl(BookmarkModel* model,
  37                            const BookmarkNodeData::Element& element,
  38                            const BookmarkNode* parent,
  39                            int index_to_add_at,
  40                            bool reset_node_times) {
  41   const BookmarkNode* cloned_node = NULL;
  42   if (element.is_url) {
  43     if (reset_node_times) {
  44       cloned_node = model->AddURL(parent, index_to_add_at, element.title,
  45                                   element.url);
  46     } else {
  47       DCHECK(!element.date_added.is_null());
  48       cloned_node = model->AddURLWithCreationTime(parent, index_to_add_at,
  49                                                   element.title, element.url,
  50                                                   element.date_added);
  51     }
  52   } else {
  53     cloned_node = model->AddFolder(parent, index_to_add_at, element.title);
  54     if (!reset_node_times) {
  55       DCHECK(!element.date_folder_modified.is_null());
  56       model->SetDateFolderModified(cloned_node, element.date_folder_modified);
  57     }
  58     for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
  59       CloneBookmarkNodeImpl(model, element.children[i], cloned_node, i,
  60                             reset_node_times);
  61   }
  62   model->SetNodeMetaInfoMap(cloned_node, element.meta_info_map);
  63 }
  64
  65 // Comparison function that compares based on date modified of the two nodes.
  66 bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
  67   return n1->date_folder_modified() > n2->date_folder_modified();
  68 }
  69
  70 // Returns true if |text| contains each string in |words|. This is used when
  71 // searching for bookmarks.
  72 bool DoesBookmarkTextContainWords(const base::string16& text,
  73                                   const std::vector<base::string16>& words) {
  74   for (size_t i = 0; i < words.size(); ++i) {
  75     if (!base::i18n::StringSearchIgnoringCaseAndAccents(
  76             words[i], text, NULL, NULL)) {
  77       return false;
  78     }
  79   }
  80   return true;
  81 }
  82
  83 // Returns true if |node|s title or url contains the strings in |words|.
  84 // |languages| argument is user's accept-language setting to decode IDN.
  85 bool DoesBookmarkContainWords(const BookmarkNode* node,
  86                               const std::vector<base::string16>& words,
  87                               const std::string& languages) {
  88   return
  89       DoesBookmarkTextContainWords(node->GetTitle(), words) ||
  90       DoesBookmarkTextContainWords(
  91           base::UTF8ToUTF16(node->url().spec()), words) ||
  92       DoesBookmarkTextContainWords(net::FormatUrl(
  93           node->url(), languages, net::kFormatUrlOmitNothing,
  94           net::UnescapeRule::NORMAL, NULL, NULL, NULL), words);
  95 }
  96
  97 // This is used with a tree iterator to skip subtrees which are not visible.
  98 bool PruneInvisibleFolders(const BookmarkNode* node) {
  99   return !node->IsVisible();
 100 }
 101
 102 // This traces parents up to root, determines if node is contained in a
 103 // selected folder.
 104 bool HasSelectedAncestor(BookmarkModel* model,
 105                          const std::vector<const BookmarkNode*>& selected_nodes,
 106                          const BookmarkNode* node) {
 107   if (!node || model->is_permanent_node(node))
 108     return false;
 109
 110   for (size_t i = 0; i < selected_nodes.size(); ++i)
 111     if (node->id() == selected_nodes[i]->id())
 112       return true;
 113
 114   return HasSelectedAncestor(model, selected_nodes, node->parent());
 115 }
 116
 117 }  // namespace
 118
 119 namespace bookmark_utils {
 120
 121 QueryFields::QueryFields() {}
 122 QueryFields::~QueryFields() {}
 123
 124 void CloneBookmarkNode(BookmarkModel* model,
 125                        const std::vector<BookmarkNodeData::Element>& elements,
 126                        const BookmarkNode* parent,
 127                        int index_to_add_at,
 128                        bool reset_node_times) {
 129   if (!parent->is_folder() || !model) {
 130     NOTREACHED();
 131     return;
 132   }
 133   for (size_t i = 0; i < elements.size(); ++i) {
 134     CloneBookmarkNodeImpl(model, elements[i], parent, index_to_add_at + i,
 135                           reset_node_times);
 136   }
 137 }
 138
 139 void CopyToClipboard(BookmarkModel* model,
 140                      const std::vector<const BookmarkNode*>& nodes,
 141                      bool remove_nodes) {
 142   if (nodes.empty())
 143     return;
 144
 145   // Create array of selected nodes with descendants filtered out.
 146   std::vector<const BookmarkNode*> filtered_nodes;
 147   for (size_t i = 0; i < nodes.size(); ++i)
 148     if (!HasSelectedAncestor(model, nodes, nodes[i]->parent()))
 149       filtered_nodes.push_back(nodes[i]);
 150
 151   BookmarkNodeData(filtered_nodes).
 152       WriteToClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE);
 153
 154   if (remove_nodes) {
 155 #if !defined(OS_ANDROID)
 156     ScopedGroupBookmarkActions group_cut(model);
 157 #endif
 158     for (size_t i = 0; i < filtered_nodes.size(); ++i) {
 159       int index = filtered_nodes[i]->parent()->GetIndexOf(filtered_nodes[i]);
 160       if (index > -1)
 161         model->Remove(filtered_nodes[i]->parent(), index);
 162     }
 163   }
 164 }
 165
 166 void PasteFromClipboard(BookmarkModel* model,
 167                         const BookmarkNode* parent,
 168                         int index) {
 169   if (!parent)
 170     return;
 171
 172   BookmarkNodeData bookmark_data;
 173   if (!bookmark_data.ReadFromClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE))
 174     return;
 175
 176   if (index == -1)
 177     index = parent->child_count();
 178 #if !defined(OS_ANDROID)
 179   ScopedGroupBookmarkActions group_paste(model);
 180 #endif
 181   CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
 182 }
 183
 184 bool CanPasteFromClipboard(const BookmarkNode* node) {
 185   if (!node)
 186     return false;
 187   return BookmarkNodeData::ClipboardContainsBookmarks();
 188 }
 189
 190 std::vector<const BookmarkNode*> GetMostRecentlyModifiedFolders(
 191     BookmarkModel* model,
 192     size_t max_count) {
 193   std::vector<const BookmarkNode*> nodes;
 194   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node(),
 195                                                     PruneInvisibleFolders);
 196
 197   while (iterator.has_next()) {
 198     const BookmarkNode* parent = iterator.Next();
 199     if (parent->is_folder() && parent->date_folder_modified() > base::Time()) {
 200       if (max_count == 0) {
 201         nodes.push_back(parent);
 202       } else {
 203         std::vector<const BookmarkNode*>::iterator i =
 204             std::upper_bound(nodes.begin(), nodes.end(), parent,
 205                              &MoreRecentlyModified);
 206         if (nodes.size() < max_count || i != nodes.end()) {
 207           nodes.insert(i, parent);
 208           while (nodes.size() > max_count)
 209             nodes.pop_back();
 210         }
 211       }
 212     }  // else case, the root node, which we don't care about or imported nodes
 213        // (which have a time of 0).
 214   }
 215
 216   if (nodes.size() < max_count) {
 217     // Add the permanent nodes if there is space. The permanent nodes are the
 218     // only children of the root_node.
 219     const BookmarkNode* root_node = model->root_node();
 220
 221     for (int i = 0; i < root_node->child_count(); ++i) {
 222       const BookmarkNode* node = root_node->GetChild(i);
 223       if (node->IsVisible() &&
 224           std::find(nodes.begin(), nodes.end(), node) == nodes.end()) {
 225         nodes.push_back(node);
 226
 227         if (nodes.size() == max_count)
 228           break;
 229       }
 230     }
 231   }
 232   return nodes;
 233 }
 234
 235 void GetMostRecentlyAddedEntries(BookmarkModel* model,
 236                                  size_t count,
 237                                  std::vector<const BookmarkNode*>* nodes) {
 238   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
 239   while (iterator.has_next()) {
 240     const BookmarkNode* node = iterator.Next();
 241     if (node->is_url()) {
 242       std::vector<const BookmarkNode*>::iterator insert_position =
 243           std::upper_bound(nodes->begin(), nodes->end(), node,
 244                            &MoreRecentlyAdded);
 245       if (nodes->size() < count || insert_position != nodes->end()) {
 246         nodes->insert(insert_position, node);
 247         while (nodes->size() > count)
 248           nodes->pop_back();
 249       }
 250     }
 251   }
 252 }
 253
 254 bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
 255   return n1->date_added() > n2->date_added();
 256 }
 257
 258 void GetBookmarksMatchingProperties(BookmarkModel* model,
 259                                     const QueryFields& query,
 260                                     size_t max_count,
 261                                     const std::string& languages,
 262                                     std::vector<const BookmarkNode*>* nodes) {
 263   std::vector<base::string16> query_words;
 264   QueryParser parser;
 265   if (query.word_phrase_query) {
 266     parser.ParseQueryWords(base::i18n::ToLower(*query.word_phrase_query),
 267                            &query_words);
 268     if (query_words.empty())
 269       return;
 270   }
 271
 272   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
 273   while (iterator.has_next()) {
 274     const BookmarkNode* node = iterator.Next();
 275     if ((!query_words.empty() &&
 276         !DoesBookmarkContainWords(node, query_words, languages)) ||
 277         model->is_permanent_node(node)) {
 278       continue;
 279     }
 280     if (query.url) {
 281       // Check against bare url spec and IDN-decoded url.
 282       if (!node->is_url() ||
 283           !(base::UTF8ToUTF16(node->url().spec()) == *query.url ||
 284             net::FormatUrl(
 285                 node->url(), languages, net::kFormatUrlOmitNothing,
 286                 net::UnescapeRule::NORMAL, NULL, NULL, NULL) == *query.url)) {
 287         continue;
 288       }
 289     }
 290     if (query.title && node->GetTitle() != *query.title)
 291       continue;
 292
 293     nodes->push_back(node);
 294     if (nodes->size() == max_count)
 295       return;
 296   }
 297 }
 298
 299 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 300   registry->RegisterBooleanPref(
 301       prefs::kShowBookmarkBar,
 302       false,
 303       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 304   registry->RegisterBooleanPref(
 305       prefs::kEditBookmarksEnabled,
 306       true,
 307       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 308   registry->RegisterBooleanPref(
 309       prefs::kShowAppsShortcutInBookmarkBar,
 310       true,
 311       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 312 }
 313
 314 const BookmarkNode* GetParentForNewNodes(
 315     const BookmarkNode* parent,
 316     const std::vector<const BookmarkNode*>& selection,
 317     int* index) {
 318   const BookmarkNode* real_parent = parent;
 319
 320   if (selection.size() == 1 && selection[0]->is_folder())
 321     real_parent = selection[0];
 322
 323   if (index) {
 324     if (selection.size() == 1 && selection[0]->is_url()) {
 325       *index = real_parent->GetIndexOf(selection[0]) + 1;
 326       if (*index == 0) {
 327         // Node doesn't exist in parent, add to end.
 328         NOTREACHED();
 329         *index = real_parent->child_count();
 330       }
 331     } else {
 332       *index = real_parent->child_count();
 333     }
 334   }
 335
 336   return real_parent;
 337 }
 338
 339 void DeleteBookmarkFolders(BookmarkModel* model,
 340                            const std::vector<int64>& ids) {
 341   // Remove the folders that were removed. This has to be done after all the
 342   // other changes have been committed.
 343   for (std::vector<int64>::const_iterator iter = ids.begin();
 344        iter != ids.end();
 345        ++iter) {
 346     const BookmarkNode* node = model->GetNodeByID(*iter);
 347     if (!node)
 348       continue;
 349     const BookmarkNode* parent = node->parent();
 350     model->Remove(parent, parent->GetIndexOf(node));
 351   }
 352 }
 353
 354 void AddIfNotBookmarked(BookmarkModel* model,
 355                         const GURL& url,
 356                         const base::string16& title) {
 357   std::vector<const BookmarkNode*> bookmarks;
 358   model->GetNodesByURL(url, &bookmarks);
 359   if (!bookmarks.empty())
 360     return;  // Nothing to do, a bookmark with that url already exists.
 361
 362   content::RecordAction(base::UserMetricsAction("BookmarkAdded"));
 363   const BookmarkNode* parent = model->GetParentForNewNodes();
 364   model->AddURL(parent, parent->child_count(), title, url);
 365 }
 366
 367 void RemoveAllBookmarks(BookmarkModel* model, const GURL& url) {
 368   std::vector<const BookmarkNode*> bookmarks;
 369   model->GetNodesByURL(url, &bookmarks);
 370
 371   // Remove all the bookmarks.
 372   for (size_t i = 0; i < bookmarks.size(); ++i) {
 373     const BookmarkNode* node = bookmarks[i];
 374     int index = node->parent()->GetIndexOf(node);
 375     if (index > -1)
 376       model->Remove(node->parent(), index);
 377   }
 378 }
 379
 380 }  // namespace bookmark_utils