components/bookmarks/browser/bookmark_utils.cc

   1 // Copyright 2014 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 "components/bookmarks/browser/bookmark_utils.h"
   6
   7 #include <utility>
   8
   9 #include "base/basictypes.h"
  10 #include "base/bind.h"
  11 #include "base/containers/hash_tables.h"
  12 #include "base/files/file_path.h"
  13 #include "base/i18n/case_conversion.h"
  14 #include "base/i18n/string_search.h"
  15 #include "base/metrics/user_metrics_action.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/time/time.h"
  21 #include "components/bookmarks/browser/bookmark_client.h"
  22 #include "components/bookmarks/browser/bookmark_model.h"
  23 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
  24 #include "components/bookmarks/common/bookmark_pref_names.h"
  25 #include "components/pref_registry/pref_registry_syncable.h"
  26 #include "components/query_parser/query_parser.h"
  27 #include "net/base/net_util.h"
  28 #include "ui/base/clipboard/clipboard.h"
  29 #include "ui/base/models/tree_node_iterator.h"
  30 #include "url/gurl.h"
  31
  32 using base::Time;
  33
  34 namespace bookmarks {
  35
  36 namespace {
  37
  38 // The maximum length of URL or title returned by the Cleanup functions.
  39 const size_t kCleanedUpUrlMaxLength = 1024u;
  40 const size_t kCleanedUpTitleMaxLength = 1024u;
  41
  42 void CloneBookmarkNodeImpl(BookmarkModel* model,
  43                            const BookmarkNodeData::Element& element,
  44                            const BookmarkNode* parent,
  45                            int index_to_add_at,
  46                            bool reset_node_times) {
  47   // Make sure to not copy non clonable keys.
  48   BookmarkNode::MetaInfoMap meta_info_map = element.meta_info_map;
  49   for (const std::string& key : model->non_cloned_keys())
  50     meta_info_map.erase(key);
  51
  52   if (element.is_url) {
  53     Time date_added = reset_node_times ? Time::Now() : element.date_added;
  54     DCHECK(!date_added.is_null());
  55
  56     model->AddURLWithCreationTimeAndMetaInfo(parent,
  57                                              index_to_add_at,
  58                                              element.title,
  59                                              element.url,
  60                                              date_added,
  61                                              &meta_info_map);
  62   } else {
  63     const BookmarkNode* cloned_node = model->AddFolderWithMetaInfo(
  64         parent, index_to_add_at, element.title, &meta_info_map);
  65     if (!reset_node_times) {
  66       DCHECK(!element.date_folder_modified.is_null());
  67       model->SetDateFolderModified(cloned_node, element.date_folder_modified);
  68     }
  69     for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
  70       CloneBookmarkNodeImpl(model, element.children[i], cloned_node, i,
  71                             reset_node_times);
  72   }
  73 }
  74
  75 // Comparison function that compares based on date modified of the two nodes.
  76 bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
  77   return n1->date_folder_modified() > n2->date_folder_modified();
  78 }
  79
  80 // Returns true if |text| contains each string in |words|. This is used when
  81 // searching for bookmarks.
  82 bool DoesBookmarkTextContainWords(const base::string16& text,
  83                                   const std::vector<base::string16>& words) {
  84   for (size_t i = 0; i < words.size(); ++i) {
  85     if (!base::i18n::StringSearchIgnoringCaseAndAccents(
  86             words[i], text, NULL, NULL)) {
  87       return false;
  88     }
  89   }
  90   return true;
  91 }
  92
  93 // Returns true if |node|s title or url contains the strings in |words|.
  94 // |languages| argument is user's accept-language setting to decode IDN.
  95 bool DoesBookmarkContainWords(const BookmarkNode* node,
  96                               const std::vector<base::string16>& words,
  97                               const std::string& languages) {
  98   return
  99       DoesBookmarkTextContainWords(node->GetTitle(), words) ||
 100       DoesBookmarkTextContainWords(
 101           base::UTF8ToUTF16(node->url().spec()), words) ||
 102       DoesBookmarkTextContainWords(net::FormatUrl(
 103           node->url(), languages, net::kFormatUrlOmitNothing,
 104           net::UnescapeRule::NORMAL, NULL, NULL, NULL), words);
 105 }
 106
 107 // This is used with a tree iterator to skip subtrees which are not visible.
 108 bool PruneInvisibleFolders(const BookmarkNode* node) {
 109   return !node->IsVisible();
 110 }
 111
 112 // This traces parents up to root, determines if node is contained in a
 113 // selected folder.
 114 bool HasSelectedAncestor(BookmarkModel* model,
 115                          const std::vector<const BookmarkNode*>& selected_nodes,
 116                          const BookmarkNode* node) {
 117   if (!node || model->is_permanent_node(node))
 118     return false;
 119
 120   for (size_t i = 0; i < selected_nodes.size(); ++i)
 121     if (node->id() == selected_nodes[i]->id())
 122       return true;
 123
 124   return HasSelectedAncestor(model, selected_nodes, node->parent());
 125 }
 126
 127 const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64 id) {
 128   if (node->id() == id)
 129     return node;
 130
 131   for (int i = 0, child_count = node->child_count(); i < child_count; ++i) {
 132     const BookmarkNode* result = GetNodeByID(node->GetChild(i), id);
 133     if (result)
 134       return result;
 135   }
 136   return NULL;
 137 }
 138
 139 // Attempts to shorten a URL safely (i.e., by preventing the end of the URL
 140 // from being in the middle of an escape sequence) to no more than
 141 // kCleanedUpUrlMaxLength characters, returning the result.
 142 std::string TruncateUrl(const std::string& url) {
 143   if (url.length() <= kCleanedUpUrlMaxLength)
 144     return url;
 145
 146   // If we're in the middle of an escape sequence, truncate just before it.
 147   if (url[kCleanedUpUrlMaxLength - 1] == '%')
 148     return url.substr(0, kCleanedUpUrlMaxLength - 1);
 149   if (url[kCleanedUpUrlMaxLength - 2] == '%')
 150     return url.substr(0, kCleanedUpUrlMaxLength - 2);
 151
 152   return url.substr(0, kCleanedUpUrlMaxLength);
 153 }
 154
 155 // Returns the URL from the clipboard. If there is no URL an empty URL is
 156 // returned.
 157 GURL GetUrlFromClipboard() {
 158   base::string16 url_text;
 159 #if !defined(OS_IOS)
 160   ui::Clipboard::GetForCurrentThread()->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE,
 161                                                  &url_text);
 162 #endif
 163   return GURL(url_text);
 164 }
 165
 166 class VectorIterator {
 167  public:
 168   explicit VectorIterator(std::vector<const BookmarkNode*>* nodes)
 169       : nodes_(nodes), current_(nodes->begin()) {}
 170   bool has_next() { return (current_ != nodes_->end()); }
 171   const BookmarkNode* Next() {
 172     const BookmarkNode* result = *current_;
 173     ++current_;
 174     return result;
 175   }
 176
 177  private:
 178   std::vector<const BookmarkNode*>* nodes_;
 179   std::vector<const BookmarkNode*>::iterator current_;
 180
 181   DISALLOW_COPY_AND_ASSIGN(VectorIterator);
 182 };
 183
 184 template <class type>
 185 void GetBookmarksMatchingPropertiesImpl(
 186     type& iterator,
 187     BookmarkModel* model,
 188     const QueryFields& query,
 189     const std::vector<base::string16>& query_words,
 190     size_t max_count,
 191     const std::string& languages,
 192     std::vector<const BookmarkNode*>* nodes) {
 193   while (iterator.has_next()) {
 194     const BookmarkNode* node = iterator.Next();
 195     if ((!query_words.empty() &&
 196          !DoesBookmarkContainWords(node, query_words, languages)) ||
 197         model->is_permanent_node(node)) {
 198       continue;
 199     }
 200     if (query.title && node->GetTitle() != *query.title)
 201       continue;
 202
 203     nodes->push_back(node);
 204     if (nodes->size() == max_count)
 205       return;
 206   }
 207 }
 208
 209 }  // namespace
 210
 211 QueryFields::QueryFields() {}
 212 QueryFields::~QueryFields() {}
 213
 214 void CloneBookmarkNode(BookmarkModel* model,
 215                        const std::vector<BookmarkNodeData::Element>& elements,
 216                        const BookmarkNode* parent,
 217                        int index_to_add_at,
 218                        bool reset_node_times) {
 219   if (!parent->is_folder() || !model) {
 220     NOTREACHED();
 221     return;
 222   }
 223   for (size_t i = 0; i < elements.size(); ++i) {
 224     CloneBookmarkNodeImpl(model, elements[i], parent,
 225                           index_to_add_at + static_cast<int>(i),
 226                           reset_node_times);
 227   }
 228 }
 229
 230 void CopyToClipboard(BookmarkModel* model,
 231                      const std::vector<const BookmarkNode*>& nodes,
 232                      bool remove_nodes) {
 233   if (nodes.empty())
 234     return;
 235
 236   // Create array of selected nodes with descendants filtered out.
 237   std::vector<const BookmarkNode*> filtered_nodes;
 238   for (size_t i = 0; i < nodes.size(); ++i)
 239     if (!HasSelectedAncestor(model, nodes, nodes[i]->parent()))
 240       filtered_nodes.push_back(nodes[i]);
 241
 242   BookmarkNodeData(filtered_nodes).
 243       WriteToClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE);
 244
 245   if (remove_nodes) {
 246     ScopedGroupBookmarkActions group_cut(model);
 247     for (size_t i = 0; i < filtered_nodes.size(); ++i) {
 248       int index = filtered_nodes[i]->parent()->GetIndexOf(filtered_nodes[i]);
 249       if (index > -1)
 250         model->Remove(filtered_nodes[i]);
 251     }
 252   }
 253 }
 254
 255 // Updates |title| such that |url| and |title| pair are unique among the
 256 // children of |parent|.
 257 void MakeTitleUnique(const BookmarkModel* model,
 258                      const BookmarkNode* parent,
 259                      const GURL& url,
 260                      base::string16* title) {
 261   base::hash_set<base::string16> titles;
 262   for (int i = 0; i < parent->child_count(); i++) {
 263     const BookmarkNode* node = parent->GetChild(i);
 264     if (node->is_url() && (url == node->url()) &&
 265         base::StartsWith(node->GetTitle(), *title, false)) {
 266       titles.insert(node->GetTitle());
 267     }
 268   }
 269
 270   if (titles.find(*title) == titles.end())
 271     return;
 272
 273   for (size_t i = 0; i < titles.size(); i++) {
 274     const base::string16 new_title(*title +
 275                                    base::ASCIIToUTF16(base::StringPrintf(
 276                                        " (%lu)", (unsigned long)(i + 1))));
 277     if (titles.find(new_title) == titles.end()) {
 278       *title = new_title;
 279       return;
 280     }
 281   }
 282   NOTREACHED();
 283 }
 284
 285 void PasteFromClipboard(BookmarkModel* model,
 286                         const BookmarkNode* parent,
 287                         int index) {
 288   if (!parent)
 289     return;
 290
 291   BookmarkNodeData bookmark_data;
 292   if (!bookmark_data.ReadFromClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE)) {
 293     GURL url = GetUrlFromClipboard();
 294     if (!url.is_valid())
 295       return;
 296     BookmarkNode node(url);
 297     node.SetTitle(base::ASCIIToUTF16(url.spec()));
 298     bookmark_data = BookmarkNodeData(&node);
 299   }
 300   if (index == -1)
 301     index = parent->child_count();
 302   ScopedGroupBookmarkActions group_paste(model);
 303
 304   if (bookmark_data.size() == 1 &&
 305       model->IsBookmarked(bookmark_data.elements[0].url)) {
 306     MakeTitleUnique(model,
 307                     parent,
 308                     bookmark_data.elements[0].url,
 309                     &bookmark_data.elements[0].title);
 310   }
 311
 312   CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
 313 }
 314
 315 bool CanPasteFromClipboard(BookmarkModel* model, const BookmarkNode* node) {
 316   if (!node || !model->client()->CanBeEditedByUser(node))
 317     return false;
 318   return (BookmarkNodeData::ClipboardContainsBookmarks() ||
 319           GetUrlFromClipboard().is_valid());
 320 }
 321
 322 std::vector<const BookmarkNode*> GetMostRecentlyModifiedUserFolders(
 323     BookmarkModel* model,
 324     size_t max_count) {
 325   std::vector<const BookmarkNode*> nodes;
 326   ui::TreeNodeIterator<const BookmarkNode> iterator(
 327       model->root_node(), base::Bind(&PruneInvisibleFolders));
 328
 329   while (iterator.has_next()) {
 330     const BookmarkNode* parent = iterator.Next();
 331     if (!model->client()->CanBeEditedByUser(parent))
 332       continue;
 333     if (parent->is_folder() && parent->date_folder_modified() > Time()) {
 334       if (max_count == 0) {
 335         nodes.push_back(parent);
 336       } else {
 337         std::vector<const BookmarkNode*>::iterator i =
 338             std::upper_bound(nodes.begin(), nodes.end(), parent,
 339                              &MoreRecentlyModified);
 340         if (nodes.size() < max_count || i != nodes.end()) {
 341           nodes.insert(i, parent);
 342           while (nodes.size() > max_count)
 343             nodes.pop_back();
 344         }
 345       }
 346     }  // else case, the root node, which we don't care about or imported nodes
 347        // (which have a time of 0).
 348   }
 349
 350   if (nodes.size() < max_count) {
 351     // Add the permanent nodes if there is space. The permanent nodes are the
 352     // only children of the root_node.
 353     const BookmarkNode* root_node = model->root_node();
 354
 355     for (int i = 0; i < root_node->child_count(); ++i) {
 356       const BookmarkNode* node = root_node->GetChild(i);
 357       if (node->IsVisible() && model->client()->CanBeEditedByUser(node) &&
 358           std::find(nodes.begin(), nodes.end(), node) == nodes.end()) {
 359         nodes.push_back(node);
 360
 361         if (nodes.size() == max_count)
 362           break;
 363       }
 364     }
 365   }
 366   return nodes;
 367 }
 368
 369 void GetMostRecentlyAddedEntries(BookmarkModel* model,
 370                                  size_t count,
 371                                  std::vector<const BookmarkNode*>* nodes) {
 372   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
 373   while (iterator.has_next()) {
 374     const BookmarkNode* node = iterator.Next();
 375     if (node->is_url()) {
 376       std::vector<const BookmarkNode*>::iterator insert_position =
 377           std::upper_bound(nodes->begin(), nodes->end(), node,
 378                            &MoreRecentlyAdded);
 379       if (nodes->size() < count || insert_position != nodes->end()) {
 380         nodes->insert(insert_position, node);
 381         while (nodes->size() > count)
 382           nodes->pop_back();
 383       }
 384     }
 385   }
 386 }
 387
 388 bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
 389   return n1->date_added() > n2->date_added();
 390 }
 391
 392 void GetBookmarksMatchingProperties(BookmarkModel* model,
 393                                     const QueryFields& query,
 394                                     size_t max_count,
 395                                     const std::string& languages,
 396                                     std::vector<const BookmarkNode*>* nodes) {
 397   std::vector<base::string16> query_words;
 398   query_parser::QueryParser parser;
 399   if (query.word_phrase_query) {
 400     parser.ParseQueryWords(base::i18n::ToLower(*query.word_phrase_query),
 401                            query_parser::MatchingAlgorithm::DEFAULT,
 402                            &query_words);
 403     if (query_words.empty())
 404       return;
 405   }
 406
 407   if (query.url) {
 408     // Shortcut into the BookmarkModel if searching for URL.
 409     GURL url(*query.url);
 410     std::vector<const BookmarkNode*> url_matched_nodes;
 411     if (url.is_valid())
 412       model->GetNodesByURL(url, &url_matched_nodes);
 413     bookmarks::VectorIterator iterator(&url_matched_nodes);
 414     GetBookmarksMatchingPropertiesImpl<bookmarks::VectorIterator>(
 415         iterator, model, query, query_words, max_count, languages, nodes);
 416   } else {
 417     ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
 418     GetBookmarksMatchingPropertiesImpl<
 419         ui::TreeNodeIterator<const BookmarkNode>>(
 420         iterator, model, query, query_words, max_count, languages, nodes);
 421   }
 422 }
 423
 424 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 425   registry->RegisterBooleanPref(
 426       prefs::kShowBookmarkBar,
 427       false,
 428       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 429   registry->RegisterBooleanPref(prefs::kEditBookmarksEnabled, true);
 430   registry->RegisterBooleanPref(
 431       prefs::kShowAppsShortcutInBookmarkBar,
 432       true,
 433       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 434   registry->RegisterBooleanPref(
 435       prefs::kShowManagedBookmarksInBookmarkBar,
 436       true,
 437       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 438 }
 439
 440 const BookmarkNode* GetParentForNewNodes(
 441     const BookmarkNode* parent,
 442     const std::vector<const BookmarkNode*>& selection,
 443     int* index) {
 444   const BookmarkNode* real_parent = parent;
 445
 446   if (selection.size() == 1 && selection[0]->is_folder())
 447     real_parent = selection[0];
 448
 449   if (index) {
 450     if (selection.size() == 1 && selection[0]->is_url()) {
 451       *index = real_parent->GetIndexOf(selection[0]) + 1;
 452       if (*index == 0) {
 453         // Node doesn't exist in parent, add to end.
 454         NOTREACHED();
 455         *index = real_parent->child_count();
 456       }
 457     } else {
 458       *index = real_parent->child_count();
 459     }
 460   }
 461
 462   return real_parent;
 463 }
 464
 465 void DeleteBookmarkFolders(BookmarkModel* model,
 466                            const std::vector<int64>& ids) {
 467   // Remove the folders that were removed. This has to be done after all the
 468   // other changes have been committed.
 469   for (std::vector<int64>::const_iterator iter = ids.begin();
 470        iter != ids.end();
 471        ++iter) {
 472     const BookmarkNode* node = GetBookmarkNodeByID(model, *iter);
 473     if (!node)
 474       continue;
 475     model->Remove(node);
 476   }
 477 }
 478
 479 void AddIfNotBookmarked(BookmarkModel* model,
 480                         const GURL& url,
 481                         const base::string16& title) {
 482   if (IsBookmarkedByUser(model, url))
 483     return;  // Nothing to do, a user bookmark with that url already exists.
 484   model->client()->RecordAction(base::UserMetricsAction("BookmarkAdded"));
 485   const BookmarkNode* parent = model->GetParentForNewNodes();
 486   model->AddURL(parent, parent->child_count(), title, url);
 487 }
 488
 489 void RemoveAllBookmarks(BookmarkModel* model, const GURL& url) {
 490   std::vector<const BookmarkNode*> bookmarks;
 491   model->GetNodesByURL(url, &bookmarks);
 492
 493   // Remove all the user bookmarks.
 494   for (size_t i = 0; i < bookmarks.size(); ++i) {
 495     const BookmarkNode* node = bookmarks[i];
 496     int index = node->parent()->GetIndexOf(node);
 497     if (index > -1 && model->client()->CanBeEditedByUser(node))
 498       model->Remove(node);
 499   }
 500 }
 501
 502 base::string16 CleanUpUrlForMatching(
 503     const GURL& gurl,
 504     const std::string& languages,
 505     base::OffsetAdjuster::Adjustments* adjustments) {
 506   base::OffsetAdjuster::Adjustments tmp_adjustments;
 507   return base::i18n::ToLower(net::FormatUrlWithAdjustments(
 508       GURL(TruncateUrl(gurl.spec())), languages,
 509       net::kFormatUrlOmitUsernamePassword,
 510       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS,
 511       NULL, NULL, adjustments ? adjustments : &tmp_adjustments));
 512 }
 513
 514 base::string16 CleanUpTitleForMatching(const base::string16& title) {
 515   return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
 516 }
 517
 518 bool CanAllBeEditedByUser(BookmarkClient* client,
 519                           const std::vector<const BookmarkNode*>& nodes) {
 520   for (size_t i = 0; i < nodes.size(); ++i) {
 521     if (!client->CanBeEditedByUser(nodes[i]))
 522       return false;
 523   }
 524   return true;
 525 }
 526
 527 bool IsBookmarkedByUser(BookmarkModel* model, const GURL& url) {
 528   std::vector<const BookmarkNode*> nodes;
 529   model->GetNodesByURL(url, &nodes);
 530   for (size_t i = 0; i < nodes.size(); ++i) {
 531     if (model->client()->CanBeEditedByUser(nodes[i]))
 532       return true;
 533   }
 534   return false;
 535 }
 536
 537 const BookmarkNode* GetBookmarkNodeByID(const BookmarkModel* model, int64 id) {
 538   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
 539   return GetNodeByID(model->root_node(), id);
 540 }
 541
 542 bool IsDescendantOf(const BookmarkNode* node, const BookmarkNode* root) {
 543   return node && node->HasAncestor(root);
 544 }
 545
 546 bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
 547                       const BookmarkNode* root) {
 548   for (const BookmarkNode* node : list) {
 549     if (IsDescendantOf(node, root))
 550       return true;
 551   }
 552   return false;
 553 }
 554
 555 }  // namespace bookmarks