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"
 #include "base/bind_helpers.h"
 #include "base/i18n/string_compare.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
+#include "base/values.h"
 #include "components/bookmarks/browser/bookmark_expanded_state_tracker.h"
 #include "components/bookmarks/browser/bookmark_index.h"
 #include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_node_data.h"
 #include "components/bookmarks/browser/bookmark_storage.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
+#include "components/bookmarks/browser/managed_bookmarks_tracker.h"
 #include "components/favicon_base/favicon_types.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/favicon_size.h"
 
 using base::Time;
 using bookmarks::BookmarkLoadDetails;
 using bookmarks::BookmarkStorage;
 
 namespace {
@@ skipping 58 matching lines @@
 
 // BookmarkModel --------------------------------------------------------------
 
 BookmarkModel::BookmarkModel(BookmarkClient* client, bool index_urls)
     : client_(client),
       loaded_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       mobile_node_(NULL),
+      managed_node_(NULL),
       next_node_id_(1),
       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       index_urls_(index_urls),
       loaded_signal_(true, false),
       extensive_changes_(0) {
   DCHECK(client_);
 }
 
 BookmarkModel::~BookmarkModel() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
@@ skipping 23 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner) {
   if (store_.get()) {
     // If the store is non-null, it means Load was already invoked. Load should
     // only be invoked once.
     NOTREACHED();
     return;
   }
 
   expanded_state_tracker_.reset(
       new BookmarkExpandedStateTracker(this, pref_service));
+  managed_bookmarks_tracker_.reset(
+      new ManagedBookmarksTracker(this, pref_service));
 
   // Load the bookmarks. BookmarkStorage notifies us when done.
   store_ = new BookmarkStorage(this, profile_path, io_task_runner.get());
-  store_->LoadBookmarks(CreateLoadDetails(accept_languages), ui_task_runner);
+  store_->LoadBookmarks(
+      CreateLoadDetails(accept_languages),
+      managed_bookmarks_tracker_->GetInitialManagedBookmarks(),
+      ui_task_runner);
+}
+
+bool BookmarkModel::IsManaged(const BookmarkNode* node) const {
+  DCHECK(loaded_);
+  while (node && node != managed_node())
+    node = node->parent();
+  return node == managed_node();
 }
 
 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
   std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetMostRecentlyModifiedFolders(this, 1);
   DCHECK(!nodes.empty());  // This list is always padded with default folders.
   return nodes[0];
 }
 
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
@@ skipping 46 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);
+
+      // The managed bookmarks can't be removed.

[sky, 2014/05/30 22:31:37]

Not removing managed bookmarks makes this function name and the observer name
confusing. I think you should rename RemoveAll to RemoveAllUserEditableNodes and
update the observer functions similarly. That'll force you to make sure doing
this doesn't cause any problems. If you could do the rename in a separate patch,
that would be great.

[Joao da Silva, 2014/06/01 13:32:07]

Agreed, I'll rename in a subsequent CL.

+      if (permanent_node == managed_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)) {
+  // The managed node can change its title.

[sky, 2014/05/30 22:31:37]

Why do we want to allow the managed nodes title to change?

[Joao da Silva, 2014/06/01 13:32:07]

This was the UX decision when we first introduced managed bookmarks on the
mobile platforms: if the bookmarks come from cloud policy then the folder name
is "$DOMAIN bookmarks", otherwise it's "Managed bookmarks" (e.g. the policy came
via MDM).

The title can change at runtime if the user signs in or out of a managed
account.

+  if (is_permanent_node(node) && node != managed_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) {
+  if (IsManaged(node)) {
+    NOTREACHED();
+    return;
+  }
   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 168 matching lines @@
 
   return AddNode(AsMutable(parent), index, new_node);
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
   if (!parent || !parent->is_folder() || is_root_node(parent) ||
       parent->child_count() <= 1) {
     return;
   }
 
+  if (IsManaged(parent)) {

[sky, 2014/05/30 22:31:37]

Should this be a DCHECK? Same with 673 and 454.

[Joao da Silva, 2014/06/01 13:32:07]

Done.

+    NOTREACHED();
+    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) {
+  if (IsManaged(parent)) {
+    NOTREACHED();
+    return;
+  }
+
   // 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 41 matching lines @@
 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_;
     case BookmarkNode::MOBILE:
       return mobile_node_;
+    case BookmarkNode::MANAGED:
+      return managed_node_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
   BookmarkNode tmp_node(url);
   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
           nodes_ordered_by_url_set_.end());
@@ skipping 34 matching lines @@
     // If bookmarks file changed externally, the IDs may have changed
     // externally. In that case, the decoder may have reassigned IDs to make
     // 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();
+  managed_node_ = details->release_managed_node();
   index_.reset(details->release_index());
 
   // 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_,
+      bookmark_bar_node_, other_node_, mobile_node_, managed_node_,
   };
   std::stable_sort(root_children,
                    root_children + arraysize(root_children),
                    VisibilityComparator(client_));
   for (size_t i = 0; i < arraysize(root_children); ++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_);
   }
 
   loaded_ = true;
 
   loaded_signal_.Signal();
 
   // Notify our direct observers.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelLoaded(this, details->ids_reassigned()));
+
+  // Start tracking the managed bookmarks. This will detect any changes that
+  // may have occurred while the |store_| loaded the initial managed bookmarks.
+  // May be NULL in unit tests.
+  if (managed_bookmarks_tracker_)
+    managed_bookmarks_tracker_->Init();
 }
 
 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) {
   scoped_ptr<BookmarkNode> node(delete_me);
 
   const BookmarkNode* parent = node->parent();
   DCHECK(parent);
   int index = parent->GetIndexOf(node.get());
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
@@ skipping 73 matching lines @@
                                  bool allow_end) {
   return (parent && parent->is_folder() &&
           (index >= 0 && (index < parent->child_count() ||
                           (allow_end && index == parent->child_count()))));
 }
 
 BookmarkPermanentNode* BookmarkModel::CreatePermanentNode(
     BookmarkNode::Type type) {
   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
          type == BookmarkNode::OTHER_NODE ||
-         type == BookmarkNode::MOBILE);
+         type == BookmarkNode::MOBILE ||
+         type == BookmarkNode::MANAGED);
   BookmarkPermanentNode* node =
       new BookmarkPermanentNode(generate_next_node_id());
   node->set_visible(client_->IsPermanentNodeVisible(type));
 
   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;
+    case BookmarkNode::MANAGED:
+      title_id = IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_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;
 }
 
@@ skipping 64 matching lines @@
 }
 
 scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails(
     const std::string& accept_languages) {
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
+  BookmarkPermanentNode* managed_node =
+      CreatePermanentNode(BookmarkNode::MANAGED);
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
+      managed_node,
       new BookmarkIndex(client_, index_urls_, accept_languages),
       next_node_id_));
 }