BookmarkClient can add extra nodes to BookmarkModel.

components/bookmarks/browser/bookmark_model.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_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 class VisibilityComparator
     : public std::binary_function<const BookmarkPermanentNode*,
                                   const BookmarkPermanentNode*,
                                   bool> {
  public:
   explicit VisibilityComparator(BookmarkClient* client) : client_(client) {}
 
   // Returns true if |n1| preceeds |n2|.
   bool operator()(const BookmarkPermanentNode* n1,
                   const BookmarkPermanentNode* n2) {
-    bool n1_visible = client_->IsPermanentNodeVisible(n1->type());
-    bool n2_visible = client_->IsPermanentNodeVisible(n2->type());
+    bool n1_visible = client_->IsPermanentNodeVisible(n1);
+    bool n2_visible = client_->IsPermanentNodeVisible(n2);
     return n1_visible != n2_visible && n1_visible;
   }
 
  private:
   BookmarkClient* client_;
 };
 
 // Comparator used when sorting bookmarks. Folders are sorted first, then
 // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
@@ skipping 136 matching lines @@
                     OnWillRemoveAllBookmarks(this));
 
   BeginExtensiveChanges();
   // Skip deleting permanent nodes. Permanent bookmark nodes are the root and
   // its immediate children. For removing all non permanent nodes just remove
   // all children of non-root permanent nodes.
   {
     base::AutoLock url_lock(url_lock_);
     for (int i = 0; i < root_.child_count(); ++i) {
       BookmarkNode* permanent_node = root_.GetChild(i);
+
+      if (!client_->CanRemoveNode(permanent_node))
+        continue;
+
       for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
         BookmarkNode* child_node = permanent_node->GetChild(j);
         removed_nodes.push_back(child_node);
         RemoveNodeAndGetRemovedUrls(child_node, &removed_urls);
       }
     }
   }
   EndExtensiveChanges();
   if (store_.get())
     store_->ScheduleSave();
@@ skipping 87 matching lines @@
 
 void BookmarkModel::SetTitle(const BookmarkNode* node,
                              const base::string16& title) {
   if (!node) {
     NOTREACHED();
     return;
   }
   if (node->GetTitle() == title)
     return;
 
-  if (is_permanent_node(node)) {
+  if (is_permanent_node(node) && !client_->CanSetTitle(node)) {
     NOTREACHED();
     return;
   }
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillChangeBookmarkNode(this, node));
 
   // The title index doesn't support changing the title, instead we remove then
   // add it back.
   index_->Remove(node);
@@ skipping 91 matching lines @@
   if (AsMutable(node)->DeleteMetaInfo(key) && store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkMetaInfoChanged(this, node));
 }
 
 void BookmarkModel::SetNodeSyncTransactionVersion(
     const BookmarkNode* node,
     int64 sync_transaction_version) {
+  DCHECK(client_->CanSyncNode(node));
+
   if (sync_transaction_version == node->sync_transaction_version())
     return;
 
   AsMutable(node)->set_sync_transaction_version(sync_transaction_version);
   if (store_.get())
     store_->ScheduleSave();
 }
 
 void BookmarkModel::OnFaviconChanged(const std::set<GURL>& urls) {
   // Ignore events if |Load| has not been called yet.
@@ skipping 163 matching lines @@
   {
     // Only hold the lock for the duration of the insert.
     base::AutoLock url_lock(url_lock_);
     nodes_ordered_by_url_set_.insert(new_node);
   }
 
   return AddNode(AsMutable(parent), index, new_node);
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
+  DCHECK(client_->CanReorderChildren(parent));
+
   if (!parent || !parent->is_folder() || is_root_node(parent) ||
       parent->child_count() <= 1) {
     return;
   }
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillReorderBookmarkNode(this, parent));
 
   UErrorCode error = U_ZERO_ERROR;
   scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
   if (U_FAILURE(error))
     collator.reset(NULL);
   BookmarkNode* mutable_parent = AsMutable(parent);
   std::sort(mutable_parent->children().begin(),
             mutable_parent->children().end(),
             SortComparator(collator.get()));
 
   if (store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeChildrenReordered(this, parent));
 }
 
 void BookmarkModel::ReorderChildren(
     const BookmarkNode* parent,
     const std::vector<const BookmarkNode*>& ordered_nodes) {
+  DCHECK(client_->CanReorderChildren(parent));
+
   // Ensure that all children in |parent| are in |ordered_nodes|.
   DCHECK_EQ(static_cast<size_t>(parent->child_count()), ordered_nodes.size());
   for (size_t i = 0; i < ordered_nodes.size(); ++i)
     DCHECK_EQ(parent, ordered_nodes[i]->parent());
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillReorderBookmarkNode(this, parent));
 
   AsMutable(parent)->SetChildren(
       *(reinterpret_cast<const std::vector<BookmarkNode*>*>(&ordered_nodes)));
@@ skipping 27 matching lines @@
 
   index_->GetBookmarksMatching(text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
   store_ = NULL;
 }
 
 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
                                             bool value) {
-  AsMutable(PermanentNode(type))->set_visible(
-      value || client_->IsPermanentNodeVisible(type));
+  BookmarkPermanentNode* node = AsMutable(PermanentNode(type));
+  node->set_visible(value || client_->IsPermanentNodeVisible(node));
 }
 
 const BookmarkPermanentNode* BookmarkModel::PermanentNode(
     BookmarkNode::Type type) {
   DCHECK(loaded_);
   switch (type) {
     case BookmarkNode::BOOKMARK_BAR:
       return bookmark_bar_node_;
     case BookmarkNode::OTHER_NODE:
       return other_node_;
@@ skipping 48 matching lines @@
     // them unique. So when the file has changed externally, we should save the
     // bookmarks file to persist new IDs.
     if (store_.get())
       store_->ScheduleSave();
   }
   bookmark_bar_node_ = details->release_bb_node();
   other_node_ = details->release_other_folder_node();
   mobile_node_ = details->release_mobile_folder_node();
   index_.reset(details->release_index());
 
+  // Get any extra nodes and take ownership of them at the |root_|.
+  std::vector<BookmarkPermanentNode*> extra_nodes;
+  details->release_extra_nodes(&extra_nodes);
+
+  // Let the client get handles to the extra permanent nodes on the main thread.
+  client_->ExtraNodesLoaded(extra_nodes);

[sky, 2014/06/04 20:39:52]

Can this be nuked and instead use BookmarkModelLoaded and dig out the nodes?
Alternatively can't the callback track the created nodes if it wants to?

[Joao da Silva, 2014/06/04 22:35:58]

BookmarkModelLoaded() comes a tad too late, because the stable_sort below relies
on IsPermanentNodeVisible(), which requires the client to have handles to the
extra nodes. The nodes can also be out-of-order by then, again due to the sort.

But the callback can indeed track the extra nodes and this call is redundant, so
Done!

+
   // WARNING: order is important here, various places assume the order is
   // constant (but can vary between embedders with the initial visibility
   // of permanent nodes).
-  BookmarkPermanentNode* root_children[] = {
-      bookmark_bar_node_, other_node_, mobile_node_,
-  };
-  std::stable_sort(root_children,
-                   root_children + arraysize(root_children),
+  std::vector<BookmarkPermanentNode*> root_children;
+  root_children.push_back(bookmark_bar_node_);
+  root_children.push_back(other_node_);
+  root_children.push_back(mobile_node_);
+  for (size_t i = 0; i < extra_nodes.size(); ++i)
+    root_children.push_back(extra_nodes[i]);
+  std::stable_sort(root_children.begin(),
+                   root_children.end(),
                    VisibilityComparator(client_));
-  for (size_t i = 0; i < arraysize(root_children); ++i) {
+  for (size_t i = 0; i < root_children.size(); ++i)
     root_.Add(root_children[i], static_cast<int>(i));
-  }
 
   root_.SetMetaInfoMap(details->model_meta_info_map());
   root_.set_sync_transaction_version(details->model_sync_transaction_version());
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
@@ skipping 93 matching lines @@
                           (allow_end && index == parent->child_count()))));
 }
 
 BookmarkPermanentNode* BookmarkModel::CreatePermanentNode(
     BookmarkNode::Type type) {
   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
          type == BookmarkNode::OTHER_NODE ||
          type == BookmarkNode::MOBILE);
   BookmarkPermanentNode* node =
       new BookmarkPermanentNode(generate_next_node_id());
-  node->set_visible(client_->IsPermanentNodeVisible(type));
+  node->set_type(type);
+  node->set_visible(client_->IsPermanentNodeVisible(node));
 
   int title_id;
   switch (type) {
     case BookmarkNode::BOOKMARK_BAR:
       title_id = IDS_BOOKMARK_BAR_FOLDER_NAME;
       break;
     case BookmarkNode::OTHER_NODE:
       title_id = IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME;
       break;
     case BookmarkNode::MOBILE:
       title_id = IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME;
       break;
     default:
       NOTREACHED();
       title_id = IDS_BOOKMARK_BAR_FOLDER_NAME;
       break;
   }
   node->SetTitle(l10n_util::GetStringUTF16(title_id));
-  node->set_type(type);
   return node;
 }
 
 void BookmarkModel::OnFaviconDataAvailable(
     BookmarkNode* node,
     favicon_base::IconType icon_type,
     const favicon_base::FaviconImageResult& image_result) {
   DCHECK(node);
   node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   node->set_favicon_state(BookmarkNode::LOADED_FAVICON);
@@ skipping 61 matching lines @@
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
+      client_->GetLoadExtraNodesCallback(),
       new BookmarkIndex(client_, index_urls_, accept_languages),
       next_node_id_));
 }