Managed bookmarks for supervised users

chrome/browser/android/bookmarks/bookmarks_bridge.cc

 // Copyright 2013 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/android/bookmarks/bookmarks_bridge.h"
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/containers/stack_container.h"
 #include "base/i18n/string_compare.h"
@@ skipping 213 matching lines @@
                                            jboolean get_normal,
                                            jobject j_result_obj) {
   DCHECK(IsLoaded());
   std::vector<const BookmarkNode*> top_level_folders;
 
   if (get_special) {
     if (client_->managed_node() &&
         client_->managed_node()->child_count() > 0) {
       top_level_folders.push_back(client_->managed_node());
     }
+    if (client_->supervised_node() &&
+        client_->supervised_node()->child_count() > 0) {
+      top_level_folders.push_back(client_->supervised_node());
+    }
     if (partner_bookmarks_shim_->HasPartnerBookmarks()) {
       top_level_folders.push_back(
           partner_bookmarks_shim_->GetPartnerBookmarksRoot());
     }
   }
   std::size_t special_count = top_level_folders.size();
 
   if (get_normal) {
     DCHECK_EQ(bookmark_model_->root_node()->child_count(), 4);
 
@@ skipping 218 matching lines @@
   for (std::list<const BookmarkNode*>::iterator folder_iter = folders.begin();
       folder_iter != folders.end(); ++folder_iter) {
     if (*folder_iter == NULL)
       continue;
 
     std::list<const BookmarkNode*>::iterator insert_iter = folder_iter;
     ++insert_iter;
 
     for (int i = 0; i < (*folder_iter)->child_count(); ++i) {
       const BookmarkNode* child = (*folder_iter)->GetChild(i);
-      if (!IsReachable(child) || client_->IsDescendantOfManagedNode(child))
+      if (!IsReachable(child) ||
+          client_->IsDescendantOfManagedOrSupervisedNode(child)) {
         continue;
+      }
 
       if (child->is_folder()) {
         insert_iter = folders.insert(insert_iter, child);
       } else {
         result.push_back(child);
       }
     }
   }
 
   std::sort(
@@ skipping 380 matching lines @@
 bool BookmarksBridge::IsLoaded() const {
   return (bookmark_model_->loaded() && partner_bookmarks_shim_->IsLoaded());
 }
 
 bool BookmarksBridge::IsFolderAvailable(
     const BookmarkNode* folder) const {
   // The managed bookmarks folder is not shown if there are no bookmarks
   // configured via policy.
   if (folder == client_->managed_node() && folder->empty())
     return false;
+  // Similarly, the supervised bookmarks folder is not shown if there are no
+  // bookmarks configured by the custodian.
+  if (folder == client_->supervised_node() && folder->empty())
+    return false;
 
   SigninManager* signin = SigninManagerFactory::GetForProfile(
       profile_->GetOriginalProfile());
   return (folder->type() != BookmarkNode::BOOKMARK_BAR &&
       folder->type() != BookmarkNode::OTHER_NODE) ||
       (signin && signin->IsAuthenticated());
 }
 
 void BookmarksBridge::NotifyIfDoneLoading() {
   if (!IsLoaded())
@@ skipping 166 matching lines @@
   BookmarkModelChanged();
 }
 
 void BookmarksBridge::PartnerShimLoaded(PartnerBookmarksShim* shim) {
   NotifyIfDoneLoading();
 }
 
 void BookmarksBridge::ShimBeingDeleted(PartnerBookmarksShim* shim) {
   partner_bookmarks_shim_ = NULL;
 }