Limit access to ChromeBookmarkClient to bookmarks code

chrome/browser/bookmarks/chrome_bookmark_client.cc

Index: chrome/browser/bookmarks/chrome_bookmark_client.cc
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.cc b/chrome/browser/bookmarks/chrome_bookmark_client.cc
index a3ca17a783545e887cc048085eb02816f16de113..d08a72a3b242d8fe6da592b132bb119c73401e99 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client.cc
+++ b/chrome/browser/bookmarks/chrome_bookmark_client.cc
@@ -63,10 +63,7 @@ void LoadInitialContents(BookmarkPermanentNode* node,
 }  // namespace
 
 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
-    : profile_(profile),
-      model_(nullptr),
-      managed_node_(nullptr),
-      supervised_node_(nullptr) {
+    : profile_(profile) {
 }
 
 ChromeBookmarkClient::~ChromeBookmarkClient() {
@@ -74,39 +71,19 @@ ChromeBookmarkClient::~ChromeBookmarkClient() {
 
 void ChromeBookmarkClient::Init(BookmarkModel* model) {
   DCHECK(model);
-  DCHECK(!model_);
-  model_ = model;
-  model_->AddObserver(this);
-
   managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
-      model_,
+      model,
       profile_->GetPrefs(),
       false,
       base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
                  base::Unretained(this))));
   supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
-      model_,
+      model,
       profile_->GetPrefs(),
       true,
       base::Callback<std::string()>()));
 }
 
-void ChromeBookmarkClient::Shutdown() {
-  if (model_) {
-    model_->RemoveObserver(this);
-    model_ = nullptr;
-  }
-  BookmarkClient::Shutdown();
-}
-
-bool ChromeBookmarkClient::PreferTouchIcon() {
-#if !defined(OS_IOS)
-  return false;
-#else
-  return true;
-#endif
-}
-
 base::CancelableTaskTracker::TaskId
 ChromeBookmarkClient::GetFaviconImageForPageURL(
     const GURL& page_url,
@@ -158,79 +135,31 @@ void ChromeBookmarkClient::GetTypedCountForNodes(
   }
 }
 
-bool ChromeBookmarkClient::IsPermanentNodeVisible(
-    const BookmarkPermanentNode* node) {
-  DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR ||
-         node->type() == BookmarkNode::OTHER_NODE ||
-         node->type() == BookmarkNode::MOBILE ||
-         node == managed_node_ ||
-         node == supervised_node_);
-  if (node == managed_node_ || node == supervised_node_)
-    return false;
-#if !defined(OS_IOS)
-  return node->type() != BookmarkNode::MOBILE;
-#else
-  return node->type() == BookmarkNode::MOBILE;
-#endif
-}
-
 void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) {
   content::RecordAction(action);
 }
 
-bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() {
-  // Create the managed_node_ and supervised_node_ with a temporary ID of 0 now.
-  // They will be populated (and assigned proper IDs) in the LoadExtraNodes
-  // callback.
-  // The ownership of managed_node_ and supervised_node_ is in limbo until
-  // LoadExtraNodes runs, so we leave them in the care of the closure meanwhile.
-  scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0));
-  managed_node_ = managed.get();
-  scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(0));
-  supervised_node_ = supervised.get();
-
+bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback(
+    scoped_ptr<bookmarks::BookmarkPermanentNode> managed_node,
+    scoped_ptr<bookmarks::BookmarkPermanentNode> supervised_node,
+    const ExtraNodeLoadedCallback& callback) {
   return base::Bind(
       &ChromeBookmarkClient::LoadExtraNodes,
-      base::Passed(&managed),
+      base::Passed(&managed_node),
       base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()),
-      base::Passed(&supervised),
-      base::Passed(
-          supervised_bookmarks_tracker_->GetInitialManagedBookmarks()));
+      base::Passed(&supervised_node),
+      base::Passed(supervised_bookmarks_tracker_->GetInitialManagedBookmarks()),
+      callback);
 }
 
-bool ChromeBookmarkClient::CanSetPermanentNodeTitle(
-    const BookmarkNode* permanent_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(permanent_node, managed_node_) &&
-          !bookmarks::IsDescendantOf(permanent_node, supervised_node_)) ||
-         permanent_node == managed_node_ ||
-         permanent_node == supervised_node_;
-}
-
-bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
-  return !bookmarks::IsDescendantOf(node, managed_node_) &&
-         !bookmarks::IsDescendantOf(node, supervised_node_);
-}
-
-bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) {
-  return !bookmarks::IsDescendantOf(node, managed_node_) &&
-         !bookmarks::IsDescendantOf(node, supervised_node_);
-}
-
-void ChromeBookmarkClient::BookmarkModelChanged() {
-}
-
-void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model,
-                                               bool ids_reassigned) {
-  BaseBookmarkModelObserver::BookmarkModelLoaded(model, ids_reassigned);
+void ChromeBookmarkClient::DoneLoading(
+    bookmarks::BookmarkPermanentNode* managed_node,
+    bookmarks::BookmarkPermanentNode* supervised_node) {
   // Start tracking the managed and supervised bookmarks. This will detect any
   // changes that may have occurred while the initial managed and supervised
   // bookmarks were being loaded on the background.
-  managed_bookmarks_tracker_->Init(managed_node_);
-  supervised_bookmarks_tracker_->Init(supervised_node_);
+  managed_bookmarks_tracker_->Init(managed_node);
+  supervised_bookmarks_tracker_->Init(supervised_node);
 }
 
 // static
@@ -239,6 +168,7 @@ bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
     scoped_ptr<base::ListValue> initial_managed_bookmarks,
     scoped_ptr<BookmarkPermanentNode> supervised_node,
     scoped_ptr<base::ListValue> initial_supervised_bookmarks,
+    const ExtraNodeLoadedCallback& callback,
     int64* next_node_id) {
   LoadInitialContents(
       managed_node.get(), initial_managed_bookmarks.get(), next_node_id);
@@ -250,8 +180,11 @@ bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
   supervised_node->SetTitle(l10n_util::GetStringUTF16(
       IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME));
 
-  bookmarks::BookmarkPermanentNodeList extra_nodes;
+  if (!callback.is_null())
+    callback.Run(managed_node.get(), supervised_node.get());
+
   // Ownership of the managed and supervised nodes passed to the caller.
+  bookmarks::BookmarkPermanentNodeList extra_nodes;
   extra_nodes.push_back(managed_node.release());
   extra_nodes.push_back(supervised_node.release());