BookmarkClient can add extra nodes to BookmarkModel.

chrome/browser/bookmarks/chrome_bookmark_client.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 "chrome/browser/bookmarks/chrome_bookmark_client.h"
 
 #include "base/logging.h"
+#include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/favicon/favicon_changed_details.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/url_database.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/user_metrics.h"
+#include "grit/components_strings.h"
+#include "policy/policy_constants.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 void NotifyHistoryOfRemovedURLs(Profile* profile,
                                 const std::set<GURL>& removed_urls) {
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
   if (history_service)
     history_service->URLsNoLongerBookmarked(removed_urls);
 }
 
 }  // namespace
 
 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile, bool index_urls)
     : profile_(profile),
-      model_(new BookmarkModel(this, index_urls)) {
+      model_(new BookmarkModel(this, index_urls)),
+      managed_bookmarks_tracker_(
+          model_.get(),
+          profile_->GetPrefs(),
+          base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
+                     base::Unretained(this))),
+      managed_node_(NULL) {
   model_->AddObserver(this);
   // Listen for changes to favicons so that we can update the favicon of the
   // node appropriately.
   registrar_.Add(this,
                  chrome::NOTIFICATION_FAVICON_CHANGED,
                  content::Source<Profile>(profile_));
 }
 
 ChromeBookmarkClient::~ChromeBookmarkClient() {
   model_->RemoveObserver(this);
 
   registrar_.RemoveAll();
 }
 
+bool ChromeBookmarkClient::IsAManagedNode(const BookmarkNode* node) {
+  while (node && node != managed_node_)

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

return node->HasAncestor(managed_node_);

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

Done.

+    node = node->parent();
+  return node == managed_node_;
+}
+
 bool ChromeBookmarkClient::PreferTouchIcon() {
 #if !defined(OS_IOS)
   return false;
 #else
   return true;
 #endif
 }
 
 base::CancelableTaskTracker::TaskId ChromeBookmarkClient::GetFaviconImageForURL(
     const GURL& page_url,
@@ skipping 35 matching lines @@
 
     NodeTypedCountPair pair(*i, typed_count);
     node_typed_count_pairs->push_back(pair);
   }
 }
 
 void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) {
   content::RecordAction(action);
 }
 
-bool ChromeBookmarkClient::IsPermanentNodeVisible(int node_type) {
-  DCHECK(node_type == BookmarkNode::BOOKMARK_BAR ||
-         node_type == BookmarkNode::OTHER_NODE ||
-         node_type == BookmarkNode::MOBILE);
+bool ChromeBookmarkClient::IsPermanentNodeVisible(const BookmarkNode* node) {
+  DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR ||
+         node->type() == BookmarkNode::OTHER_NODE ||
+         node->type() == BookmarkNode::MOBILE ||
+         node == managed_node_);
+  if (node == managed_node_)
+    return false;
 #if !defined(OS_IOS)
-  return node_type != BookmarkNode::MOBILE;
+  return node->type() != BookmarkNode::MOBILE;
 #else
-  return node_type == BookmarkNode::MOBILE;
+  return node->type() == BookmarkNode::MOBILE;
 #endif
 }
 
+bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() {
+  return base::Bind(
+      &ChromeBookmarkClient::LoadExtraNodes,
+      base::Passed(managed_bookmarks_tracker_.GetInitialManagedBookmarks()));
+}
+
+void ChromeBookmarkClient::ExtraNodesLoaded(
+    const std::vector<BookmarkPermanentNode*>& extra_nodes) {
+  CHECK_EQ(1u, extra_nodes.size());
+  managed_node_ = extra_nodes[0];
+}
+
+bool ChromeBookmarkClient::CanRemoveNode(const BookmarkNode* node) {
+  return !IsAManagedNode(node);
+}
+
+bool ChromeBookmarkClient::CanSetTitle(const BookmarkNode* node) {
+  // The |managed_node_| can have its title updated if the user signs in or
+  // out.
+  return !IsAManagedNode(node) || node == managed_node_;
+}
+
+bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
+  return !IsAManagedNode(node);
+}
+
+bool ChromeBookmarkClient::CanReorderChildren(const BookmarkNode* parent) {
+  return !IsAManagedNode(parent);
+}
+
 void ChromeBookmarkClient::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_FAVICON_CHANGED: {
       content::Details<FaviconChangedDetails> favicon_details(details);
       model_->OnFaviconChanged(favicon_details->urls);
       break;
     }
@@ skipping 18 matching lines @@
     const BookmarkNode* node,
     const std::set<GURL>& removed_urls) {
   NotifyHistoryOfRemovedURLs(profile_, removed_urls);
 }
 
 void ChromeBookmarkClient::BookmarkAllNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   NotifyHistoryOfRemovedURLs(profile_, removed_urls);
 }
+
+void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model,
+                                               bool ids_reassigned) {
+  // Start tracking the managed bookmarks. This will detect any changes that
+  // may have occurred while the initial managed bookmarks were being loaded
+  // on the background.
+  managed_bookmarks_tracker_.Init(managed_node_);
+}
+
+// static
+bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
+    scoped_ptr<base::ListValue> initial_managed_bookmarks,
+    int64* next_node_id) {
+  // Create the managed node now, and load its initial contents.

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

DCHECK not on UI thread.

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

That fails in around 100 unit tests in ~10 suites, because they map all
BrowserThread::IDs to the same loop as UI.

I've made it explicit that this uses the Profile::GetIOTaskRunner and DCHECK
that that's the current runner; WDYT?

+  int64 managed_id = *next_node_id;
+  BookmarkPermanentNode* managed_node = new BookmarkPermanentNode(managed_id);
+  *next_node_id = policy::ManagedBookmarksTracker::LoadInitial(
+      managed_node, initial_managed_bookmarks.get(), managed_id + 1);
+  managed_node->set_visible(!managed_node->empty());
+  managed_node->SetTitle(
+      l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME));
+
+  bookmarks::BookmarkPermanentNodeList extra_nodes;
+  extra_nodes.push_back(managed_node);
+  return extra_nodes.Pass();
+}
+
+std::string ChromeBookmarkClient::GetManagedBookmarksDomain() {
+  policy::ProfilePolicyConnector* connector =
+      policy::ProfilePolicyConnectorFactory::GetForProfile(profile_);
+  if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks))
+    return connector->GetManagementDomain();
+  return std::string();
+}