src/components/bookmarks/browser/bookmark_model.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_model.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/i18n/string_compare.h"
  13 #include "base/logging.h"
  14 #include "base/macros.h"
  15 #include "base/strings/string_util.h"
  16 #include "components/bookmarks/browser/bookmark_expanded_state_tracker.h"
  17 #include "components/bookmarks/browser/bookmark_index.h"
  18 #include "components/bookmarks/browser/bookmark_match.h"
  19 #include "components/bookmarks/browser/bookmark_model_observer.h"
  20 #include "components/bookmarks/browser/bookmark_node_data.h"
  21 #include "components/bookmarks/browser/bookmark_storage.h"
  22 #include "components/bookmarks/browser/bookmark_utils.h"
  23 #include "components/favicon_base/favicon_types.h"
  24 #include "grit/components_strings.h"
  25 #include "ui/base/l10n/l10n_util.h"
  26 #include "ui/gfx/favicon_size.h"
  27
  28 using base::Time;
  29 using bookmarks::BookmarkExpandedStateTracker;
  30 using bookmarks::BookmarkIndex;
  31 using bookmarks::BookmarkLoadDetails;
  32 using bookmarks::BookmarkMatch;
  33 using bookmarks::BookmarkStorage;
  34
  35 namespace {
  36
  37 // Helper to get a mutable bookmark node.
  38 BookmarkNode* AsMutable(const BookmarkNode* node) {
  39   return const_cast<BookmarkNode*>(node);
  40 }
  41
  42 // Helper to get a mutable permanent bookmark node.
  43 BookmarkPermanentNode* AsMutable(const BookmarkPermanentNode* node) {
  44   return const_cast<BookmarkPermanentNode*>(node);
  45 }
  46
  47 // Comparator used when sorting permanent nodes. Nodes that are initially
  48 // visible are sorted before nodes that are initially hidden.
  49 class VisibilityComparator
  50     : public std::binary_function<const BookmarkPermanentNode*,
  51                                   const BookmarkPermanentNode*,
  52                                   bool> {
  53  public:
  54   explicit VisibilityComparator(BookmarkClient* client) : client_(client) {}
  55
  56   // Returns true if |n1| preceeds |n2|.
  57   bool operator()(const BookmarkPermanentNode* n1,
  58                   const BookmarkPermanentNode* n2) {
  59     bool n1_visible = client_->IsPermanentNodeVisible(n1);
  60     bool n2_visible = client_->IsPermanentNodeVisible(n2);
  61     return n1_visible != n2_visible && n1_visible;
  62   }
  63
  64  private:
  65   BookmarkClient* client_;
  66 };
  67
  68 // Comparator used when sorting bookmarks. Folders are sorted first, then
  69 // bookmarks.
  70 class SortComparator : public std::binary_function<const BookmarkNode*,
  71                                                    const BookmarkNode*,
  72                                                    bool> {
  73  public:
  74   explicit SortComparator(icu::Collator* collator) : collator_(collator) {}
  75
  76   // Returns true if |n1| preceeds |n2|.
  77   bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) {
  78     if (n1->type() == n2->type()) {
  79       // Types are the same, compare the names.
  80       if (!collator_)
  81         return n1->GetTitle() < n2->GetTitle();
  82       return base::i18n::CompareString16WithCollator(
  83           collator_, n1->GetTitle(), n2->GetTitle()) == UCOL_LESS;
  84     }
  85     // Types differ, sort such that folders come first.
  86     return n1->is_folder();
  87   }
  88
  89  private:
  90   icu::Collator* collator_;
  91 };
  92
  93 }  // namespace
  94
  95 // BookmarkModel --------------------------------------------------------------
  96
  97 BookmarkModel::BookmarkModel(BookmarkClient* client, bool index_urls)
  98     : client_(client),
  99       loaded_(false),
 100       root_(GURL()),
 101       bookmark_bar_node_(NULL),
 102       other_node_(NULL),
 103       mobile_node_(NULL),
 104       next_node_id_(1),
 105       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
 106       index_urls_(index_urls),
 107       loaded_signal_(true, false),
 108       extensive_changes_(0) {
 109   DCHECK(client_);
 110 }
 111
 112 BookmarkModel::~BookmarkModel() {
 113   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 114                     BookmarkModelBeingDeleted(this));
 115
 116   if (store_.get()) {
 117     // The store maintains a reference back to us. We need to tell it we're gone
 118     // so that it doesn't try and invoke a method back on us again.
 119     store_->BookmarkModelDeleted();
 120   }
 121 }
 122
 123 void BookmarkModel::Shutdown() {
 124   if (loaded_)
 125     return;
 126
 127   // See comment in HistoryService::ShutdownOnUIThread where this is invoked for
 128   // details. It is also called when the BookmarkModel is deleted.
 129   loaded_signal_.Signal();
 130 }
 131
 132 void BookmarkModel::Load(
 133     PrefService* pref_service,
 134     const std::string& accept_languages,
 135     const base::FilePath& profile_path,
 136     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
 137     const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner) {
 138   if (store_.get()) {
 139     // If the store is non-null, it means Load was already invoked. Load should
 140     // only be invoked once.
 141     NOTREACHED();
 142     return;
 143   }
 144
 145   expanded_state_tracker_.reset(
 146       new BookmarkExpandedStateTracker(this, pref_service));
 147
 148   // Load the bookmarks. BookmarkStorage notifies us when done.
 149   store_ = new BookmarkStorage(this, profile_path, io_task_runner.get());
 150   store_->LoadBookmarks(CreateLoadDetails(accept_languages), ui_task_runner);
 151 }
 152
 153 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
 154   std::vector<const BookmarkNode*> nodes =
 155       bookmark_utils::GetMostRecentlyModifiedUserFolders(this, 1);
 156   DCHECK(!nodes.empty());  // This list is always padded with default folders.
 157   return nodes[0];
 158 }
 159
 160 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
 161   observers_.AddObserver(observer);
 162 }
 163
 164 void BookmarkModel::RemoveObserver(BookmarkModelObserver* observer) {
 165   observers_.RemoveObserver(observer);
 166 }
 167
 168 void BookmarkModel::BeginExtensiveChanges() {
 169   if (++extensive_changes_ == 1) {
 170     FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 171                       ExtensiveBookmarkChangesBeginning(this));
 172   }
 173 }
 174
 175 void BookmarkModel::EndExtensiveChanges() {
 176   --extensive_changes_;
 177   DCHECK_GE(extensive_changes_, 0);
 178   if (extensive_changes_ == 0) {
 179     FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 180                       ExtensiveBookmarkChangesEnded(this));
 181   }
 182 }
 183
 184 void BookmarkModel::BeginGroupedChanges() {
 185   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 186                     GroupedBookmarkChangesBeginning(this));
 187 }
 188
 189 void BookmarkModel::EndGroupedChanges() {
 190   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 191                     GroupedBookmarkChangesEnded(this));
 192 }
 193
 194 void BookmarkModel::Remove(const BookmarkNode* parent, int index) {
 195   if (!loaded_ || !IsValidIndex(parent, index, false) || is_root_node(parent)) {
 196     NOTREACHED();
 197     return;
 198   }
 199   RemoveAndDeleteNode(AsMutable(parent->GetChild(index)));
 200 }
 201
 202 void BookmarkModel::RemoveAllUserBookmarks() {
 203   std::set<GURL> removed_urls;
 204   ScopedVector<BookmarkNode> removed_nodes;
 205
 206   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 207                     OnWillRemoveAllUserBookmarks(this));
 208
 209   BeginExtensiveChanges();
 210   // Skip deleting permanent nodes. Permanent bookmark nodes are the root and
 211   // its immediate children. For removing all non permanent nodes just remove
 212   // all children of non-root permanent nodes.
 213   {
 214     base::AutoLock url_lock(url_lock_);
 215     for (int i = 0; i < root_.child_count(); ++i) {
 216       BookmarkNode* permanent_node = root_.GetChild(i);
 217
 218       if (!client_->CanBeEditedByUser(permanent_node))
 219         continue;
 220
 221       for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
 222         BookmarkNode* child_node = permanent_node->GetChild(j);
 223         removed_nodes.push_back(child_node);
 224         RemoveNodeAndGetRemovedUrls(child_node, &removed_urls);
 225       }
 226     }
 227   }
 228   EndExtensiveChanges();
 229   if (store_.get())
 230     store_->ScheduleSave();
 231
 232   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 233                     BookmarkAllUserNodesRemoved(this, removed_urls));
 234 }
 235
 236 void BookmarkModel::Move(const BookmarkNode* node,
 237                          const BookmarkNode* new_parent,
 238                          int index) {
 239   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
 240       is_root_node(new_parent) || is_permanent_node(node)) {
 241     NOTREACHED();
 242     return;
 243   }
 244
 245   if (new_parent->HasAncestor(node)) {
 246     // Can't make an ancestor of the node be a child of the node.
 247     NOTREACHED();
 248     return;
 249   }
 250
 251   const BookmarkNode* old_parent = node->parent();
 252   int old_index = old_parent->GetIndexOf(node);
 253
 254   if (old_parent == new_parent &&
 255       (index == old_index || index == old_index + 1)) {
 256     // Node is already in this position, nothing to do.
 257     return;
 258   }
 259
 260   SetDateFolderModified(new_parent, Time::Now());
 261
 262   if (old_parent == new_parent && index > old_index)
 263     index--;
 264   BookmarkNode* mutable_new_parent = AsMutable(new_parent);
 265   mutable_new_parent->Add(AsMutable(node), index);
 266
 267   if (store_.get())
 268     store_->ScheduleSave();
 269
 270   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 271                     BookmarkNodeMoved(this, old_parent, old_index,
 272                                       new_parent, index));
 273 }
 274
 275 void BookmarkModel::Copy(const BookmarkNode* node,
 276                          const BookmarkNode* new_parent,
 277                          int index) {
 278   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
 279       is_root_node(new_parent) || is_permanent_node(node)) {
 280     NOTREACHED();
 281     return;
 282   }
 283
 284   if (new_parent->HasAncestor(node)) {
 285     // Can't make an ancestor of the node be a child of the node.
 286     NOTREACHED();
 287     return;
 288   }
 289
 290   SetDateFolderModified(new_parent, Time::Now());
 291   BookmarkNodeData drag_data(node);
 292   std::vector<BookmarkNodeData::Element> elements(drag_data.elements);
 293   // CloneBookmarkNode will use BookmarkModel methods to do the job, so we
 294   // don't need to send notifications here.
 295   bookmark_utils::CloneBookmarkNode(this, elements, new_parent, index, true);
 296
 297   if (store_.get())
 298     store_->ScheduleSave();
 299 }
 300
 301 const gfx::Image& BookmarkModel::GetFavicon(const BookmarkNode* node) {
 302   DCHECK(node);
 303   if (node->favicon_state() == BookmarkNode::INVALID_FAVICON) {
 304     BookmarkNode* mutable_node = AsMutable(node);
 305     LoadFavicon(
 306         mutable_node,
 307         client_->PreferTouchIcon() ?
 308             favicon_base::TOUCH_ICON :
 309             favicon_base::FAVICON);
 310   }
 311   return node->favicon();
 312 }
 313
 314 favicon_base::IconType BookmarkModel::GetFaviconType(const BookmarkNode* node) {
 315   DCHECK(node);
 316   return node->favicon_type();
 317 }
 318
 319 void BookmarkModel::SetTitle(const BookmarkNode* node,
 320                              const base::string16& title) {
 321   if (!node) {
 322     NOTREACHED();
 323     return;
 324   }
 325   if (node->GetTitle() == title)
 326     return;
 327
 328   if (is_permanent_node(node) && !client_->CanSetPermanentNodeTitle(node)) {
 329     NOTREACHED();
 330     return;
 331   }
 332
 333   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 334                     OnWillChangeBookmarkNode(this, node));
 335
 336   // The title index doesn't support changing the title, instead we remove then
 337   // add it back.
 338   index_->Remove(node);
 339   AsMutable(node)->SetTitle(title);
 340   index_->Add(node);
 341
 342   if (store_.get())
 343     store_->ScheduleSave();
 344
 345   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 346                     BookmarkNodeChanged(this, node));
 347 }
 348
 349 void BookmarkModel::SetURL(const BookmarkNode* node, const GURL& url) {
 350   if (!node) {
 351     NOTREACHED();
 352     return;
 353   }
 354
 355   // We cannot change the URL of a folder.
 356   if (node->is_folder()) {
 357     NOTREACHED();
 358     return;
 359   }
 360
 361   if (node->url() == url)
 362     return;
 363
 364   BookmarkNode* mutable_node = AsMutable(node);
 365   mutable_node->InvalidateFavicon();
 366   CancelPendingFaviconLoadRequests(mutable_node);
 367
 368   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 369                     OnWillChangeBookmarkNode(this, node));
 370
 371   {
 372     base::AutoLock url_lock(url_lock_);
 373     RemoveNodeFromURLSet(mutable_node);
 374     mutable_node->set_url(url);
 375     nodes_ordered_by_url_set_.insert(mutable_node);
 376   }
 377
 378   if (store_.get())
 379     store_->ScheduleSave();
 380
 381   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 382                     BookmarkNodeChanged(this, node));
 383 }
 384
 385 void BookmarkModel::SetNodeMetaInfo(const BookmarkNode* node,
 386                                     const std::string& key,
 387                                     const std::string& value) {
 388   std::string old_value;
 389   if (node->GetMetaInfo(key, &old_value) && old_value == value)
 390     return;
 391
 392   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 393                     OnWillChangeBookmarkMetaInfo(this, node));
 394
 395   if (AsMutable(node)->SetMetaInfo(key, value) && store_.get())
 396     store_->ScheduleSave();
 397
 398   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 399                     BookmarkMetaInfoChanged(this, node));
 400 }
 401
 402 void BookmarkModel::SetNodeMetaInfoMap(
 403     const BookmarkNode* node,
 404     const BookmarkNode::MetaInfoMap& meta_info_map) {
 405   const BookmarkNode::MetaInfoMap* old_meta_info_map = node->GetMetaInfoMap();
 406   if ((!old_meta_info_map && meta_info_map.empty()) ||
 407       (old_meta_info_map && meta_info_map == *old_meta_info_map))
 408     return;
 409
 410   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 411                     OnWillChangeBookmarkMetaInfo(this, node));
 412
 413   AsMutable(node)->SetMetaInfoMap(meta_info_map);
 414   if (store_.get())
 415     store_->ScheduleSave();
 416
 417   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 418                     BookmarkMetaInfoChanged(this, node));
 419 }
 420
 421 void BookmarkModel::DeleteNodeMetaInfo(const BookmarkNode* node,
 422                                        const std::string& key) {
 423   const BookmarkNode::MetaInfoMap* meta_info_map = node->GetMetaInfoMap();
 424   if (!meta_info_map || meta_info_map->find(key) == meta_info_map->end())
 425     return;
 426
 427   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 428                     OnWillChangeBookmarkMetaInfo(this, node));
 429
 430   if (AsMutable(node)->DeleteMetaInfo(key) && store_.get())
 431     store_->ScheduleSave();
 432
 433   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 434                     BookmarkMetaInfoChanged(this, node));
 435 }
 436
 437 void BookmarkModel::SetNodeSyncTransactionVersion(
 438     const BookmarkNode* node,
 439     int64 sync_transaction_version) {
 440   DCHECK(client_->CanSyncNode(node));
 441
 442   if (sync_transaction_version == node->sync_transaction_version())
 443     return;
 444
 445   AsMutable(node)->set_sync_transaction_version(sync_transaction_version);
 446   if (store_.get())
 447     store_->ScheduleSave();
 448 }
 449
 450 void BookmarkModel::OnFaviconChanged(const std::set<GURL>& urls) {
 451   // Ignore events if |Load| has not been called yet.
 452   if (!store_)
 453     return;
 454
 455   // Prevent the observers from getting confused for multiple favicon loads.
 456   for (std::set<GURL>::const_iterator i = urls.begin(); i != urls.end(); ++i) {
 457     std::vector<const BookmarkNode*> nodes;
 458     GetNodesByURL(*i, &nodes);
 459     for (size_t i = 0; i < nodes.size(); ++i) {
 460       // Got an updated favicon, for a URL, do a new request.
 461       BookmarkNode* node = AsMutable(nodes[i]);
 462       node->InvalidateFavicon();
 463       CancelPendingFaviconLoadRequests(node);
 464       FOR_EACH_OBSERVER(BookmarkModelObserver,
 465                         observers_,
 466                         BookmarkNodeFaviconChanged(this, node));
 467     }
 468   }
 469 }
 470
 471 void BookmarkModel::SetDateAdded(const BookmarkNode* node,
 472                                  Time date_added) {
 473   if (!node) {
 474     NOTREACHED();
 475     return;
 476   }
 477
 478   if (node->date_added() == date_added)
 479     return;
 480
 481   if (is_permanent_node(node)) {
 482     NOTREACHED();
 483     return;
 484   }
 485
 486   AsMutable(node)->set_date_added(date_added);
 487
 488   // Syncing might result in dates newer than the folder's last modified date.
 489   if (date_added > node->parent()->date_folder_modified()) {
 490     // Will trigger store_->ScheduleSave().
 491     SetDateFolderModified(node->parent(), date_added);
 492   } else if (store_.get()) {
 493     store_->ScheduleSave();
 494   }
 495 }
 496
 497 void BookmarkModel::GetNodesByURL(const GURL& url,
 498                                   std::vector<const BookmarkNode*>* nodes) {
 499   base::AutoLock url_lock(url_lock_);
 500   BookmarkNode tmp_node(url);
 501   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node);
 502   while (i != nodes_ordered_by_url_set_.end() && (*i)->url() == url) {
 503     nodes->push_back(*i);
 504     ++i;
 505   }
 506 }
 507
 508 const BookmarkNode* BookmarkModel::GetMostRecentlyAddedUserNodeForURL(
 509     const GURL& url) {
 510   std::vector<const BookmarkNode*> nodes;
 511   GetNodesByURL(url, &nodes);
 512   std::sort(nodes.begin(), nodes.end(), &bookmark_utils::MoreRecentlyAdded);
 513
 514   // Look for the first node that the user can edit.
 515   for (size_t i = 0; i < nodes.size(); ++i) {
 516     if (client_->CanBeEditedByUser(nodes[i]))
 517       return nodes[i];
 518   }
 519
 520   return NULL;
 521 }
 522
 523 bool BookmarkModel::HasBookmarks() {
 524   base::AutoLock url_lock(url_lock_);
 525   return !nodes_ordered_by_url_set_.empty();
 526 }
 527
 528 bool BookmarkModel::IsBookmarked(const GURL& url) {
 529   base::AutoLock url_lock(url_lock_);
 530   return IsBookmarkedNoLock(url);
 531 }
 532
 533 void BookmarkModel::GetBookmarks(
 534     std::vector<BookmarkModel::URLAndTitle>* bookmarks) {
 535   base::AutoLock url_lock(url_lock_);
 536   const GURL* last_url = NULL;
 537   for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin();
 538        i != nodes_ordered_by_url_set_.end(); ++i) {
 539     const GURL* url = &((*i)->url());
 540     // Only add unique URLs.
 541     if (!last_url || *url != *last_url) {
 542       BookmarkModel::URLAndTitle bookmark;
 543       bookmark.url = *url;
 544       bookmark.title = (*i)->GetTitle();
 545       bookmarks->push_back(bookmark);
 546     }
 547     last_url = url;
 548   }
 549 }
 550
 551 void BookmarkModel::BlockTillLoaded() {
 552   loaded_signal_.Wait();
 553 }
 554
 555 const BookmarkNode* BookmarkModel::AddFolder(const BookmarkNode* parent,
 556                                              int index,
 557                                              const base::string16& title) {
 558   return AddFolderWithMetaInfo(parent, index, title, NULL);
 559 }
 560 const BookmarkNode* BookmarkModel::AddFolderWithMetaInfo(
 561     const BookmarkNode* parent,
 562     int index,
 563     const base::string16& title,
 564     const BookmarkNode::MetaInfoMap* meta_info) {
 565   if (!loaded_ || is_root_node(parent) || !IsValidIndex(parent, index, true)) {
 566     // Can't add to the root.
 567     NOTREACHED();
 568     return NULL;
 569   }
 570
 571   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), GURL());
 572   new_node->set_date_folder_modified(Time::Now());
 573   // Folders shouldn't have line breaks in their titles.
 574   new_node->SetTitle(title);
 575   new_node->set_type(BookmarkNode::FOLDER);
 576   if (meta_info)
 577     new_node->SetMetaInfoMap(*meta_info);
 578
 579   return AddNode(AsMutable(parent), index, new_node);
 580 }
 581
 582 const BookmarkNode* BookmarkModel::AddURL(const BookmarkNode* parent,
 583                                           int index,
 584                                           const base::string16& title,
 585                                           const GURL& url) {
 586   return AddURLWithCreationTimeAndMetaInfo(
 587       parent,
 588       index,
 589       base::CollapseWhitespace(title, false),
 590       url,
 591       Time::Now(),
 592       NULL);
 593 }
 594
 595 const BookmarkNode* BookmarkModel::AddURLWithCreationTimeAndMetaInfo(
 596     const BookmarkNode* parent,
 597     int index,
 598     const base::string16& title,
 599     const GURL& url,
 600     const Time& creation_time,
 601     const BookmarkNode::MetaInfoMap* meta_info) {
 602   if (!loaded_ || !url.is_valid() || is_root_node(parent) ||
 603       !IsValidIndex(parent, index, true)) {
 604     NOTREACHED();
 605     return NULL;
 606   }
 607
 608   // Syncing may result in dates newer than the last modified date.
 609   if (creation_time > parent->date_folder_modified())
 610     SetDateFolderModified(parent, creation_time);
 611
 612   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), url);
 613   new_node->SetTitle(title);
 614   new_node->set_date_added(creation_time);
 615   new_node->set_type(BookmarkNode::URL);
 616   if (meta_info)
 617     new_node->SetMetaInfoMap(*meta_info);
 618
 619   {
 620     // Only hold the lock for the duration of the insert.
 621     base::AutoLock url_lock(url_lock_);
 622     nodes_ordered_by_url_set_.insert(new_node);
 623   }
 624
 625   return AddNode(AsMutable(parent), index, new_node);
 626 }
 627
 628 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
 629   DCHECK(client_->CanBeEditedByUser(parent));
 630
 631   if (!parent || !parent->is_folder() || is_root_node(parent) ||
 632       parent->child_count() <= 1) {
 633     return;
 634   }
 635
 636   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 637                     OnWillReorderBookmarkNode(this, parent));
 638
 639   UErrorCode error = U_ZERO_ERROR;
 640   scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
 641   if (U_FAILURE(error))
 642     collator.reset(NULL);
 643   BookmarkNode* mutable_parent = AsMutable(parent);
 644   std::sort(mutable_parent->children().begin(),
 645             mutable_parent->children().end(),
 646             SortComparator(collator.get()));
 647
 648   if (store_.get())
 649     store_->ScheduleSave();
 650
 651   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 652                     BookmarkNodeChildrenReordered(this, parent));
 653 }
 654
 655 void BookmarkModel::ReorderChildren(
 656     const BookmarkNode* parent,
 657     const std::vector<const BookmarkNode*>& ordered_nodes) {
 658   DCHECK(client_->CanBeEditedByUser(parent));
 659
 660   // Ensure that all children in |parent| are in |ordered_nodes|.
 661   DCHECK_EQ(static_cast<size_t>(parent->child_count()), ordered_nodes.size());
 662   for (size_t i = 0; i < ordered_nodes.size(); ++i)
 663     DCHECK_EQ(parent, ordered_nodes[i]->parent());
 664
 665   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 666                     OnWillReorderBookmarkNode(this, parent));
 667
 668   AsMutable(parent)->SetChildren(
 669       *(reinterpret_cast<const std::vector<BookmarkNode*>*>(&ordered_nodes)));
 670
 671   if (store_.get())
 672     store_->ScheduleSave();
 673
 674   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 675                     BookmarkNodeChildrenReordered(this, parent));
 676 }
 677
 678 void BookmarkModel::SetDateFolderModified(const BookmarkNode* parent,
 679                                           const Time time) {
 680   DCHECK(parent);
 681   AsMutable(parent)->set_date_folder_modified(time);
 682
 683   if (store_.get())
 684     store_->ScheduleSave();
 685 }
 686
 687 void BookmarkModel::ResetDateFolderModified(const BookmarkNode* node) {
 688   SetDateFolderModified(node, Time());
 689 }
 690
 691 void BookmarkModel::GetBookmarksMatching(
 692     const base::string16& text,
 693     size_t max_count,
 694     std::vector<BookmarkMatch>* matches) {
 695   if (!loaded_)
 696     return;
 697
 698   index_->GetBookmarksMatching(text, max_count, matches);
 699 }
 700
 701 void BookmarkModel::ClearStore() {
 702   store_ = NULL;
 703 }
 704
 705 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
 706                                             bool value) {
 707   BookmarkPermanentNode* node = AsMutable(PermanentNode(type));
 708   node->set_visible(value || client_->IsPermanentNodeVisible(node));
 709 }
 710
 711 const BookmarkPermanentNode* BookmarkModel::PermanentNode(
 712     BookmarkNode::Type type) {
 713   DCHECK(loaded_);
 714   switch (type) {
 715     case BookmarkNode::BOOKMARK_BAR:
 716       return bookmark_bar_node_;
 717     case BookmarkNode::OTHER_NODE:
 718       return other_node_;
 719     case BookmarkNode::MOBILE:
 720       return mobile_node_;
 721     default:
 722       NOTREACHED();
 723       return NULL;
 724   }
 725 }
 726
 727 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
 728   BookmarkNode tmp_node(url);
 729   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
 730           nodes_ordered_by_url_set_.end());
 731 }
 732
 733 void BookmarkModel::RemoveNode(BookmarkNode* node,
 734                                std::set<GURL>* removed_urls) {
 735   if (!loaded_ || !node || is_permanent_node(node)) {
 736     NOTREACHED();
 737     return;
 738   }
 739
 740   url_lock_.AssertAcquired();
 741   if (node->is_url()) {
 742     RemoveNodeFromURLSet(node);
 743     removed_urls->insert(node->url());
 744     index_->Remove(node);
 745   }
 746
 747   CancelPendingFaviconLoadRequests(node);
 748
 749   // Recurse through children.
 750   for (int i = node->child_count() - 1; i >= 0; --i)
 751     RemoveNode(node->GetChild(i), removed_urls);
 752 }
 753
 754 void BookmarkModel::DoneLoading(scoped_ptr<BookmarkLoadDetails> details) {
 755   DCHECK(details);
 756   if (loaded_) {
 757     // We should only ever be loaded once.
 758     NOTREACHED();
 759     return;
 760   }
 761
 762   next_node_id_ = details->max_id();
 763   if (details->computed_checksum() != details->stored_checksum() ||
 764       details->ids_reassigned()) {
 765     // If bookmarks file changed externally, the IDs may have changed
 766     // externally. In that case, the decoder may have reassigned IDs to make
 767     // them unique. So when the file has changed externally, we should save the
 768     // bookmarks file to persist new IDs.
 769     if (store_.get())
 770       store_->ScheduleSave();
 771   }
 772   bookmark_bar_node_ = details->release_bb_node();
 773   other_node_ = details->release_other_folder_node();
 774   mobile_node_ = details->release_mobile_folder_node();
 775   index_.reset(details->release_index());
 776
 777   // Get any extra nodes and take ownership of them at the |root_|.
 778   std::vector<BookmarkPermanentNode*> extra_nodes;
 779   details->release_extra_nodes(&extra_nodes);
 780
 781   // WARNING: order is important here, various places assume the order is
 782   // constant (but can vary between embedders with the initial visibility
 783   // of permanent nodes).
 784   std::vector<BookmarkPermanentNode*> root_children;
 785   root_children.push_back(bookmark_bar_node_);
 786   root_children.push_back(other_node_);
 787   root_children.push_back(mobile_node_);
 788   for (size_t i = 0; i < extra_nodes.size(); ++i)
 789     root_children.push_back(extra_nodes[i]);
 790   std::stable_sort(root_children.begin(),
 791                    root_children.end(),
 792                    VisibilityComparator(client_));
 793   for (size_t i = 0; i < root_children.size(); ++i)
 794     root_.Add(root_children[i], static_cast<int>(i));
 795
 796   root_.SetMetaInfoMap(details->model_meta_info_map());
 797   root_.set_sync_transaction_version(details->model_sync_transaction_version());
 798
 799   {
 800     base::AutoLock url_lock(url_lock_);
 801     // Update nodes_ordered_by_url_set_ from the nodes.
 802     PopulateNodesByURL(&root_);
 803   }
 804
 805   loaded_ = true;
 806
 807   loaded_signal_.Signal();
 808
 809   // Notify our direct observers.
 810   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 811                     BookmarkModelLoaded(this, details->ids_reassigned()));
 812 }
 813
 814 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) {
 815   scoped_ptr<BookmarkNode> node(delete_me);
 816
 817   const BookmarkNode* parent = node->parent();
 818   DCHECK(parent);
 819   int index = parent->GetIndexOf(node.get());
 820
 821   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 822                     OnWillRemoveBookmarks(this, parent, index, node.get()));
 823
 824   std::set<GURL> removed_urls;
 825   {
 826     base::AutoLock url_lock(url_lock_);
 827     RemoveNodeAndGetRemovedUrls(node.get(), &removed_urls);
 828   }
 829
 830   if (store_.get())
 831     store_->ScheduleSave();
 832
 833   FOR_EACH_OBSERVER(
 834       BookmarkModelObserver,
 835       observers_,
 836       BookmarkNodeRemoved(this, parent, index, node.get(), removed_urls));
 837 }
 838
 839 void BookmarkModel::RemoveNodeFromURLSet(BookmarkNode* node) {
 840   // NOTE: this is called in such a way that url_lock_ is already held. As
 841   // such, this doesn't explicitly grab the lock.
 842   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(node);
 843   DCHECK(i != nodes_ordered_by_url_set_.end());
 844   // i points to the first node with the URL, advance until we find the
 845   // node we're removing.
 846   while (*i != node)
 847     ++i;
 848   nodes_ordered_by_url_set_.erase(i);
 849 }
 850
 851 void BookmarkModel::RemoveNodeAndGetRemovedUrls(BookmarkNode* node,
 852                                                 std::set<GURL>* removed_urls) {
 853   // NOTE: this method should be always called with |url_lock_| held.
 854   // This method does not explicitly acquires a lock.
 855   url_lock_.AssertAcquired();
 856   DCHECK(removed_urls);
 857   BookmarkNode* parent = AsMutable(node->parent());
 858   DCHECK(parent);
 859   parent->Remove(node);
 860   RemoveNode(node, removed_urls);
 861   // RemoveNode adds an entry to removed_urls for each node of type URL. As we
 862   // allow duplicates we need to remove any entries that are still bookmarked.
 863   for (std::set<GURL>::iterator i = removed_urls->begin();
 864        i != removed_urls->end();) {
 865     if (IsBookmarkedNoLock(*i)) {
 866       // When we erase the iterator pointing at the erasee is
 867       // invalidated, so using i++ here within the "erase" call is
 868       // important as it advances the iterator before passing the
 869       // old value through to erase.
 870       removed_urls->erase(i++);
 871     } else {
 872       ++i;
 873     }
 874   }
 875 }
 876
 877 BookmarkNode* BookmarkModel::AddNode(BookmarkNode* parent,
 878                                      int index,
 879                                      BookmarkNode* node) {
 880   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 881                     OnWillAddBookmarkNode(this, node));
 882
 883   parent->Add(node, index);
 884
 885   if (store_.get())
 886     store_->ScheduleSave();
 887
 888   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 889                     BookmarkNodeAdded(this, parent, index));
 890
 891   index_->Add(node);
 892
 893   return node;
 894 }
 895
 896 bool BookmarkModel::IsValidIndex(const BookmarkNode* parent,
 897                                  int index,
 898                                  bool allow_end) {
 899   return (parent && parent->is_folder() &&
 900           (index >= 0 && (index < parent->child_count() ||
 901                           (allow_end && index == parent->child_count()))));
 902 }
 903
 904 BookmarkPermanentNode* BookmarkModel::CreatePermanentNode(
 905     BookmarkNode::Type type) {
 906   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
 907          type == BookmarkNode::OTHER_NODE ||
 908          type == BookmarkNode::MOBILE);
 909   BookmarkPermanentNode* node =
 910       new BookmarkPermanentNode(generate_next_node_id());
 911   node->set_type(type);
 912   node->set_visible(client_->IsPermanentNodeVisible(node));
 913
 914   int title_id;
 915   switch (type) {
 916     case BookmarkNode::BOOKMARK_BAR:
 917       title_id = IDS_BOOKMARK_BAR_FOLDER_NAME;
 918       break;
 919     case BookmarkNode::OTHER_NODE:
 920       title_id = IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME;
 921       break;
 922     case BookmarkNode::MOBILE:
 923       title_id = IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME;
 924       break;
 925     default:
 926       NOTREACHED();
 927       title_id = IDS_BOOKMARK_BAR_FOLDER_NAME;
 928       break;
 929   }
 930   node->SetTitle(l10n_util::GetStringUTF16(title_id));
 931   return node;
 932 }
 933
 934 void BookmarkModel::OnFaviconDataAvailable(
 935     BookmarkNode* node,
 936     favicon_base::IconType icon_type,
 937     const favicon_base::FaviconImageResult& image_result) {
 938   DCHECK(node);
 939   node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
 940   node->set_favicon_state(BookmarkNode::LOADED_FAVICON);
 941   if (!image_result.image.IsEmpty()) {
 942     node->set_favicon_type(icon_type);
 943     node->set_favicon(image_result.image);
 944     node->set_icon_url(image_result.icon_url);
 945     FaviconLoaded(node);
 946   } else if (icon_type == favicon_base::TOUCH_ICON) {
 947     // Couldn't load the touch icon, fallback to the regular favicon.
 948     DCHECK(client_->PreferTouchIcon());
 949     LoadFavicon(node, favicon_base::FAVICON);
 950   }
 951 }
 952
 953 void BookmarkModel::LoadFavicon(
 954     BookmarkNode* node,
 955     favicon_base::IconType icon_type) {
 956   if (node->is_folder())
 957     return;
 958
 959   DCHECK(node->url().is_valid());
 960   node->set_favicon_state(BookmarkNode::LOADING_FAVICON);
 961   base::CancelableTaskTracker::TaskId taskId = client_->GetFaviconImageForURL(
 962       node->url(),
 963       icon_type,
 964       icon_type == favicon_base::FAVICON ? gfx::kFaviconSize : 0,
 965       base::Bind(
 966           &BookmarkModel::OnFaviconDataAvailable,
 967           base::Unretained(this),
 968           node,
 969           icon_type),
 970       &cancelable_task_tracker_);
 971   if (taskId != base::CancelableTaskTracker::kBadTaskId)
 972     node->set_favicon_load_task_id(taskId);
 973 }
 974
 975 void BookmarkModel::FaviconLoaded(const BookmarkNode* node) {
 976   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
 977                     BookmarkNodeFaviconChanged(this, node));
 978 }
 979
 980 void BookmarkModel::CancelPendingFaviconLoadRequests(BookmarkNode* node) {
 981   if (node->favicon_load_task_id() != base::CancelableTaskTracker::kBadTaskId) {
 982     cancelable_task_tracker_.TryCancel(node->favicon_load_task_id());
 983     node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
 984   }
 985 }
 986
 987 void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) {
 988   // NOTE: this is called with url_lock_ already held. As such, this doesn't
 989   // explicitly grab the lock.
 990   if (node->is_url())
 991     nodes_ordered_by_url_set_.insert(node);
 992   for (int i = 0; i < node->child_count(); ++i)
 993     PopulateNodesByURL(node->GetChild(i));
 994 }
 995
 996 int64 BookmarkModel::generate_next_node_id() {
 997   return next_node_id_++;
 998 }
 999
1000 scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails(
1001     const std::string& accept_languages) {
1002   BookmarkPermanentNode* bb_node =
1003       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
1004   BookmarkPermanentNode* other_node =
1005       CreatePermanentNode(BookmarkNode::OTHER_NODE);
1006   BookmarkPermanentNode* mobile_node =
1007       CreatePermanentNode(BookmarkNode::MOBILE);
1008   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
1009       bb_node,
1010       other_node,
1011       mobile_node,
1012       client_->GetLoadExtraNodesCallback(),
1013       new BookmarkIndex(client_, index_urls_, accept_languages),
1014       next_node_id_));
1015 }