Limit access to ChromeBookmarkClient to bookmarks code

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 31 matching lines @@
   return const_cast<BookmarkPermanentNode*>(node);
 }
 
 // Comparator used when sorting permanent nodes. Nodes that are initially
 // visible are sorted before nodes that are initially hidden.
 class VisibilityComparator
     : public std::binary_function<const BookmarkPermanentNode*,
                                   const BookmarkPermanentNode*,
                                   bool> {
  public:
-  explicit VisibilityComparator(BookmarkClient* client) : client_(client) {}
+  explicit VisibilityComparator(BookmarkModel* model) : model_(model) {}
 
   // Returns true if |n1| preceeds |n2|.
   bool operator()(const BookmarkPermanentNode* n1,
                   const BookmarkPermanentNode* n2) {
-    bool n1_visible = client_->IsPermanentNodeVisible(n1);
-    bool n2_visible = client_->IsPermanentNodeVisible(n2);
+    bool n1_visible = model_->IsPermanentNodeVisible(n1);
+    bool n2_visible = model_->IsPermanentNodeVisible(n2);
     return n1_visible != n2_visible && n1_visible;
   }
 
  private:
-  BookmarkClient* client_;
+  BookmarkModel* model_;
 };
 
 // Comparator used when sorting bookmarks. Folders are sorted first, then
 // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
                                                    const BookmarkNode*,
                                                    bool> {
  public:
   explicit SortComparator(icu::Collator* collator) : collator_(collator) {}
 
@@ skipping 15 matching lines @@
 };
 
 }  // namespace
 
 // BookmarkModel --------------------------------------------------------------
 
 BookmarkModel::BookmarkModel(BookmarkClient* client)
     : client_(client),
       loaded_(false),
       root_(GURL()),
-      bookmark_bar_node_(NULL),
-      other_node_(NULL),
-      mobile_node_(NULL),
+      bookmark_bar_node_(nullptr),
+      other_node_(nullptr),
+      mobile_node_(nullptr),
+      managed_node_(nullptr),
+      supervised_node_(nullptr),
       next_node_id_(1),
       observers_(
           base::ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       loaded_signal_(true, false),
       extensive_changes_(0) {
   DCHECK(client_);
 }
 
 BookmarkModel::~BookmarkModel() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
@@ skipping 93 matching lines @@
 
   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_->CanBeEditedByUser(permanent_node))
+      if (!CanBeEditedByUser(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();
@@ skipping 66 matching lines @@
 
   if (store_.get())
     store_->ScheduleSave();
 }
 
 const gfx::Image& BookmarkModel::GetFavicon(const BookmarkNode* node) {
   DCHECK(node);
   if (node->favicon_state() == BookmarkNode::INVALID_FAVICON) {
     BookmarkNode* mutable_node = AsMutable(node);
     LoadFavicon(mutable_node,
-                client_->PreferTouchIcon() ? favicon_base::TOUCH_ICON
-                                           : favicon_base::FAVICON);
+                PreferTouchIcon() ? favicon_base::TOUCH_ICON
+                                  : favicon_base::FAVICON);
   }
   return node->favicon();
 }
 
 favicon_base::IconType BookmarkModel::GetFaviconType(const BookmarkNode* node) {
   DCHECK(node);
   return node->favicon_type();
 }
 
 void BookmarkModel::SetTitle(const BookmarkNode* node,
                              const base::string16& title) {
   DCHECK(node);
 
   if (node->GetTitle() == title)
     return;
 
-  if (is_permanent_node(node) && !client_->CanSetPermanentNodeTitle(node)) {
+  if (is_permanent_node(node) && !CanSetPermanentNodeTitle(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 86 matching lines @@
                     BookmarkMetaInfoChanged(this, node));
 }
 
 void BookmarkModel::AddNonClonedKey(const std::string& key) {
   non_cloned_keys_.insert(key);
 }
 
 void BookmarkModel::SetNodeSyncTransactionVersion(
     const BookmarkNode* node,
     int64 sync_transaction_version) {
-  DCHECK(client_->CanSyncNode(node));
+  DCHECK(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) {
@@ skipping 10 matching lines @@
       BookmarkNode* node = AsMutable(nodes[i]);
       node->InvalidateFavicon();
       CancelPendingFaviconLoadRequests(node);
       FOR_EACH_OBSERVER(BookmarkModelObserver,
                         observers_,
                         BookmarkNodeFaviconChanged(this, node));
     }
   }
 }
 
+bool BookmarkModel::CanSyncNode(const BookmarkNode* node) {
+  return !bookmarks::IsDescendantOf(node, managed_node_) &&
+         !bookmarks::IsDescendantOf(node, supervised_node_);
+}
+
+bool BookmarkModel::CanBeEditedByUser(const BookmarkNode* node) {
+  return !bookmarks::IsDescendantOf(node, managed_node_) &&
+         !bookmarks::IsDescendantOf(node, supervised_node_);
+}
+
+bool BookmarkModel::IsPermanentNodeVisible(const BookmarkPermanentNode* node) {
+  DCHECK(IsTopLevelPermanentNode(node));
+  if (node == supervised_node_ || node == managed_node_)
+    return false;
+#if !defined(OS_IOS)
+  return node->type() != BookmarkNode::MOBILE;
+#else
+  return node->type() == BookmarkNode::MOBILE;
+#endif
+}
+
+void BookmarkModel::RecordAction(const base::UserMetricsAction& action) {
+  client_->RecordAction(action);
+}
+
 void BookmarkModel::SetDateAdded(const BookmarkNode* node, Time date_added) {
   DCHECK(node && !is_permanent_node(node));
 
   if (node->date_added() == date_added)
     return;
 
   AsMutable(node)->set_date_added(date_added);
 
   // Syncing might result in dates newer than the folder's last modified date.
   if (date_added > node->parent()->date_folder_modified()) {
@@ skipping 16 matching lines @@
 }
 
 const BookmarkNode* BookmarkModel::GetMostRecentlyAddedUserNodeForURL(
     const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   GetNodesByURL(url, &nodes);
   std::sort(nodes.begin(), nodes.end(), &MoreRecentlyAdded);
 
   // Look for the first node that the user can edit.
   for (size_t i = 0; i < nodes.size(); ++i) {
-    if (client_->CanBeEditedByUser(nodes[i]))
+    if (CanBeEditedByUser(nodes[i]))
       return nodes[i];
   }
 
-  return NULL;
+  return nullptr;
 }
 
 bool BookmarkModel::HasBookmarks() {
   base::AutoLock url_lock(url_lock_);
   return !nodes_ordered_by_url_set_.empty();
 }
 
 bool BookmarkModel::IsBookmarked(const GURL& url) {
   base::AutoLock url_lock(url_lock_);
   return IsBookmarkedNoLock(url);
 }
 
 void BookmarkModel::GetBookmarks(
     std::vector<BookmarkModel::URLAndTitle>* bookmarks) {
   base::AutoLock url_lock(url_lock_);
-  const GURL* last_url = NULL;
+  const GURL* last_url = nullptr;
   for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin();
        i != nodes_ordered_by_url_set_.end(); ++i) {
     const GURL* url = &((*i)->url());
     // Only add unique URLs.
     if (!last_url || *url != *last_url) {
       BookmarkModel::URLAndTitle bookmark;
       bookmark.url = *url;
       bookmark.title = (*i)->GetTitle();
       bookmarks->push_back(bookmark);
     }
     last_url = url;
   }
 }
 
 void BookmarkModel::BlockTillLoaded() {
   loaded_signal_.Wait();
 }
 
 const BookmarkNode* BookmarkModel::AddFolder(const BookmarkNode* parent,
                                              int index,
                                              const base::string16& title) {
-  return AddFolderWithMetaInfo(parent, index, title, NULL);
+  return AddFolderWithMetaInfo(parent, index, title, nullptr);
 }
 const BookmarkNode* BookmarkModel::AddFolderWithMetaInfo(
     const BookmarkNode* parent,
     int index,
     const base::string16& title,
     const BookmarkNode::MetaInfoMap* meta_info) {
   if (!loaded_ || is_root_node(parent) || !IsValidIndex(parent, index, true)) {
     // Can't add to the root.
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), GURL());
   new_node->set_date_folder_modified(Time::Now());
   // Folders shouldn't have line breaks in their titles.
   new_node->SetTitle(title);
   new_node->set_type(BookmarkNode::FOLDER);
   if (meta_info)
     new_node->SetMetaInfoMap(*meta_info);
 
   return AddNode(AsMutable(parent), index, new_node);
 }
 
 const BookmarkNode* BookmarkModel::AddURL(const BookmarkNode* parent,
                                           int index,
                                           const base::string16& title,
                                           const GURL& url) {
   return AddURLWithCreationTimeAndMetaInfo(
       parent,
       index,
       base::CollapseWhitespace(title, false),
       url,
       Time::Now(),
-      NULL);
+      nullptr);
 }
 
 const BookmarkNode* BookmarkModel::AddURLWithCreationTimeAndMetaInfo(
     const BookmarkNode* parent,
     int index,
     const base::string16& title,
     const GURL& url,
     const Time& creation_time,
     const BookmarkNode::MetaInfoMap* meta_info) {
   if (!loaded_ || !url.is_valid() || is_root_node(parent) ||
       !IsValidIndex(parent, index, true)) {
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
 
   // Syncing may result in dates newer than the last modified date.
   if (creation_time > parent->date_folder_modified())
     SetDateFolderModified(parent, creation_time);
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), url);
   new_node->SetTitle(title);
   new_node->set_date_added(creation_time);
   new_node->set_type(BookmarkNode::URL);
   if (meta_info)
     new_node->SetMetaInfoMap(*meta_info);
 
   return AddNode(AsMutable(parent), index, new_node);
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
-  DCHECK(client_->CanBeEditedByUser(parent));
+  DCHECK(CanBeEditedByUser(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);
+    collator.reset(nullptr);
   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_->CanBeEditedByUser(parent));
+  DCHECK(CanBeEditedByUser(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(
@@ skipping 37 matching lines @@
   index_->GetBookmarksMatching(text, max_count, matching_algorithm, matches);
 }
 
 void BookmarkModel::ClearStore() {
   store_.reset();
 }
 
 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
                                             bool value) {
   BookmarkPermanentNode* node = AsMutable(PermanentNode(type));
-  node->set_visible(value || client_->IsPermanentNodeVisible(node));
+  node->set_visible(value || 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_;
     case BookmarkNode::MOBILE:
       return mobile_node_;
     default:
       NOTREACHED();
-      return NULL;
+      return nullptr;
   }
 }
 
 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());
 }
 
 void BookmarkModel::RemoveNode(BookmarkNode* node,
@@ skipping 68 matching lines @@
   for (size_t i = 0; i < extra_nodes.size(); ++i)
     root_children.push_back(extra_nodes[i]);
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/467179
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile4(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("467179 BookmarkModel::DoneLoading4"));
 
   std::stable_sort(root_children.begin(),
                    root_children.end(),
-                   VisibilityComparator(client_));
+                   VisibilityComparator(this));
   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());
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/467179
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile5(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("467179 BookmarkModel::DoneLoading5"));
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
   loaded_ = true;
 
   loaded_signal_.Signal();
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/467179
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile6(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("467179 BookmarkModel::DoneLoading6"));
 
   // Notify our direct observers.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelLoaded(this, details->ids_reassigned()));
+
+  // Notify client.
+  client_->DoneLoading(managed_node_, supervised_node_);
 }
 
 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());
   DCHECK_NE(-1, index);
 
@@ skipping 91 matching lines @@
 }
 
 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_type(type);
-  node->set_visible(client_->IsPermanentNodeVisible(node));
+  node->set_visible(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:
@@ skipping 15 matching lines @@
   DCHECK(node);
   node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   node->set_favicon_state(BookmarkNode::LOADED_FAVICON);
   if (!image_result.image.IsEmpty()) {
     node->set_favicon_type(icon_type);
     node->set_favicon(image_result.image);
     node->set_icon_url(image_result.icon_url);
     FaviconLoaded(node);
   } else if (icon_type == favicon_base::TOUCH_ICON) {
     // Couldn't load the touch icon, fallback to the regular favicon.
-    DCHECK(client_->PreferTouchIcon());
+    DCHECK(PreferTouchIcon());
     LoadFavicon(node, favicon_base::FAVICON);
   }
 }
 
 void BookmarkModel::LoadFavicon(BookmarkNode* node,
                                 favicon_base::IconType icon_type) {
   if (node->is_folder())
     return;
 
   DCHECK(node->url().is_valid());
@@ skipping 38 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);
+  // Create the managed_node and supervised_node with a temporary id of 0 now.
+  // They will be populated and assigned property ids by the LoadExtraCallback
+  // returned by GetLoadExtraNodesCallback(). Ownership of the node is
+  // transferred to the closure.
+  scoped_ptr<BookmarkPermanentNode> managed_node(new BookmarkPermanentNode(0));
+  scoped_ptr<BookmarkPermanentNode> supervised_node(
+      new BookmarkPermanentNode(0));
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
-      bb_node,
-      other_node,
-      mobile_node,
-      client_->GetLoadExtraNodesCallback(),
-      new BookmarkIndex(client_, accept_languages),
-      next_node_id_));
+      bb_node, other_node, mobile_node,
+      client_->GetLoadExtraNodesCallback(
+          managed_node.Pass(), supervised_node.Pass(),
+          base::Bind(&BookmarkModel::OnExtraNodeLoaded,
+                     base::Unretained(this))),
+      new BookmarkIndex(client_, accept_languages), next_node_id_));
+}
+
+void BookmarkModel::OnExtraNodeLoaded(BookmarkPermanentNode* managed_node,
+                                      BookmarkPermanentNode* supervised_node) {
+  managed_node_ = managed_node;
+  supervised_node_ = supervised_node;
+}
+
+bool BookmarkModel::IsTopLevelPermanentNode(const BookmarkPermanentNode* node) {
+  return node->type() == BookmarkNode::BOOKMARK_BAR ||
+         node->type() == BookmarkNode::OTHER_NODE ||
+         node->type() == BookmarkNode::MOBILE ||
+         node == supervised_node_ ||
+         node == managed_node_;
+}
+
+bool BookmarkModel::CanSetPermanentNodeTitle(const BookmarkNode* node) {
+  // The |managed_node_| can have its title updated if the user signs in or
+  // out, since the name of the managed domain can appear in it.
+  // Also, both |managed_node_| and |supervised_node_| can have their title
+  // updated on locale changes (crbug.com/459448).
+  return (!bookmarks::IsDescendantOf(node, managed_node_) &&
+          !bookmarks::IsDescendantOf(node, supervised_node_)) ||
+         node == managed_node_ || node == supervised_node_;
+}
+
+bool BookmarkModel::PreferTouchIcon() {
+#if !defined(OS_IOS)
+  return false;
+#else
+  return true;
+#endif
 }
 
 }  // namespace bookmarks