Managed bookmarks for supervised users

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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/values.h"
@@ skipping 25 matching lines @@
   if (bitmap_result.is_valid()) {
     result.image = gfx::Image::CreateFrom1xPNGBytes(
         bitmap_result.bitmap_data->front(), bitmap_result.bitmap_data->size());
     result.icon_url = bitmap_result.icon_url;
     callback.Run(result);
     return;
   }
   callback.Run(result);
 }
 
+bool IsDescendantOf(const BookmarkNode* node, const BookmarkNode* root) {
+  return node && node->HasAncestor(root);
+}
+
+// Returns true if any node in |list| is a descendant of |root|.
+bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
+                      const BookmarkNode* root) {
+  for (size_t i = 0; i < list.size(); ++i) {
+    if (IsDescendantOf(list[i], root))
+      return true;
+  }
+  return false;
+}
+
+void LoadInitialContents(BookmarkPermanentNode* node,
+                         base::ListValue* initial_bookmarks,
+                         int64* next_node_id) {
+  // Load the initial contents of the |node| now, and assign it an unused ID.
+  int64 id = *next_node_id;
+  node->set_id(id);
+  *next_node_id = policy::ManagedBookmarksTracker::LoadInitial(
+      node, initial_bookmarks, id + 1);
+  node->set_visible(!node->empty());
+}
+
 }  // namespace
 
 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
     : profile_(profile),
       history_service_(NULL),
       model_(NULL),
-      managed_node_(NULL) {
+      managed_node_(NULL),
+      supervised_node_(NULL) {
 }
 
 ChromeBookmarkClient::~ChromeBookmarkClient() {
 }
 
 void ChromeBookmarkClient::Init(BookmarkModel* model) {
   DCHECK(model);
   DCHECK(!model_);
   model_ = model;
   model_->AddObserver(this);
 
   managed_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker(
       model_,
       profile_->GetPrefs(),
+      false,
       base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
                  base::Unretained(this))));
+  supervised_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker(
+      model_,
+      profile_->GetPrefs(),
+      true,
+      base::Callback<std::string()>()));
 }
 
 void ChromeBookmarkClient::Shutdown() {
   favicon_changed_subscription_.reset();
   if (model_) {
     model_->RemoveObserver(this);
     model_ = NULL;
   }
   BookmarkClient::Shutdown();
 }
 
 bool ChromeBookmarkClient::IsDescendantOfManagedNode(const BookmarkNode* node) {
-  return node && node->HasAncestor(managed_node_);
+  return IsDescendantOf(node, managed_node_);
 }
 
 bool ChromeBookmarkClient::HasDescendantsOfManagedNode(
     const std::vector<const BookmarkNode*>& list) {
-  for (size_t i = 0; i < list.size(); ++i) {
-    if (IsDescendantOfManagedNode(list[i]))
-      return true;
-  }
-  return false;
+  return HasDescendantsOf(list, managed_node_);
+}
+
+bool ChromeBookmarkClient::IsDescendantOfSupervisedNode(
+    const BookmarkNode* node) {
+  return IsDescendantOf(node, supervised_node_);
+}
+
+bool ChromeBookmarkClient::HasDescendantsOfSupervisedNode(
+    const std::vector<const BookmarkNode*>& list) {
+  return HasDescendantsOf(list, supervised_node_);
+}
+
+bool ChromeBookmarkClient::IsDescendantOfManagedOrSupervisedNode(
+    const BookmarkNode* node) {
+  return IsDescendantOfManagedNode(node) || IsDescendantOfSupervisedNode(node);
+}
+
+bool ChromeBookmarkClient::HasDescendantsOfManagedOrSupervisedNode(
+    const std::vector<const BookmarkNode*>& list) {
+  return HasDescendantsOfManagedNode(list) ||
+         HasDescendantsOfSupervisedNode(list);
 }
 
 bool ChromeBookmarkClient::PreferTouchIcon() {
 #if !defined(OS_IOS)
   return false;
 #else
   return true;
 #endif
 }
 
@@ skipping 42 matching lines @@
     NodeTypedCountPair pair(*i, typed_count);
     node_typed_count_pairs->push_back(pair);
   }
 }
 
 bool ChromeBookmarkClient::IsPermanentNodeVisible(
     const BookmarkPermanentNode* node) {
   DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR ||
          node->type() == BookmarkNode::OTHER_NODE ||
          node->type() == BookmarkNode::MOBILE ||
-         node == managed_node_);
-  if (node == managed_node_)
+         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 now; it will be populated in the LoadExtraNodes
-  // callback.
-  // The ownership of managed_node_ is in limbo until LoadExtraNodes runs,
-  // so we leave it in the care of the closure meanwhile.
+  // Create the managed_node_ and supervised_node_ now; they will be populated
+  // 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(1));
+  supervised_node_ = supervised.get();
 
   return base::Bind(
       &ChromeBookmarkClient::LoadExtraNodes,
       base::Passed(&managed),
-      base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()));
+      base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()),
+      base::Passed(&supervised),
+      base::Passed(
+          supervised_bookmarks_tracker_->GetInitialManagedBookmarks()));
 }
 
 bool ChromeBookmarkClient::CanSetPermanentNodeTitle(
     const BookmarkNode* permanent_node) {
   // The |managed_node_| can have its title updated if the user signs in or
-  // out.
-  return !IsDescendantOfManagedNode(permanent_node) ||
+  // out, since the name of the managed domain can appear in it. The
+  // |supervised_node_| has a fixed title which can never be updated.
+  return !IsDescendantOfManagedOrSupervisedNode(permanent_node) ||
          permanent_node == managed_node_;
 }
 
 bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
-  return !IsDescendantOfManagedNode(node);
+  return !IsDescendantOfManagedOrSupervisedNode(node);
 }
 
 bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) {
-  return !IsDescendantOfManagedNode(node);
+  return !IsDescendantOfManagedOrSupervisedNode(node);
 }
 
 void ChromeBookmarkClient::SetHistoryService(HistoryService* history_service) {
   DCHECK(history_service);
   history_service_ = history_service;
   favicon_changed_subscription_ = history_service_->AddFaviconChangedCallback(
       base::Bind(&BookmarkModel::OnFaviconChanged, base::Unretained(model_)));
 }
 
 void ChromeBookmarkClient::BookmarkModelChanged() {
@@ skipping 11 matching lines @@
 
 void ChromeBookmarkClient::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   if (history_service_)
     history_service_->URLsNoLongerBookmarked(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.
+  // 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_);
 }
 
 // static
 bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
     scoped_ptr<BookmarkPermanentNode> managed_node,
     scoped_ptr<base::ListValue> initial_managed_bookmarks,
+    scoped_ptr<BookmarkPermanentNode> supervised_node,
+    scoped_ptr<base::ListValue> initial_supervised_bookmarks,
     int64* next_node_id) {
-  // Load the initial contents of the |managed_node| now, and assign it an
-  // unused ID.
-  int64 managed_id = *next_node_id;
-  managed_node->set_id(managed_id);
-  *next_node_id = policy::ManagedBookmarksTracker::LoadInitial(
-      managed_node.get(), 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));
+  LoadInitialContents(
+      managed_node.get(), initial_managed_bookmarks.get(), next_node_id);
+  managed_node->SetTitle(l10n_util::GetStringUTF16(
+      IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME));
+
+  LoadInitialContents(
+      supervised_node.get(), initial_supervised_bookmarks.get(), next_node_id);
+  supervised_node->SetTitle(l10n_util::GetStringUTF16(
+      IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME));
 
   bookmarks::BookmarkPermanentNodeList extra_nodes;
-  // Ownership of the managed node passed to the caller.
+  // Ownership of the managed and supervised nodes passed to the caller.
   extra_nodes.push_back(managed_node.release());
+  extra_nodes.push_back(supervised_node.release());
 
   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();
 }