Managed bookmarks for supervised users

chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc

 // Copyright (c) 2012 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/ui/views/bookmarks/bookmark_menu_delegate.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
@@ skipping 59 matching lines @@
   real_delegate_ = real_delegate;
   location_ = location;
   if (parent) {
     parent_menu_item_ = parent;
 
     // Add a separator if there are existing items in the menu, and if the
     // current node has children. If |node| is the bookmark bar then the
     // managed node is shown as its first child, if it's not empty.
     BookmarkModel* model = GetBookmarkModel();
     ChromeBookmarkClient* client = GetChromeBookmarkClient();
-    bool show_managed = show_options == SHOW_PERMANENT_FOLDERS &&
-                        node == model->bookmark_bar_node() &&
-                        !client->managed_node()->empty();
-    bool has_children =
-        (start_child_index < node->child_count()) || show_managed;
+    bool show_pushed = show_options == SHOW_PERMANENT_FOLDERS &&
+                       node == model->bookmark_bar_node();
+    bool show_managed = show_pushed && !client->managed_node()->empty();
+    bool show_supervised = show_pushed && !client->supervised_node()->empty();
+    bool has_children = (start_child_index < node->child_count()) ||
+                        show_managed || show_supervised;
     int initial_count = parent->GetSubmenu() ?
         parent->GetSubmenu()->GetMenuItemCount() : 0;
     if (has_children && initial_count > 0)
       parent->AppendSeparator();
     if (show_managed)
       BuildMenuForManagedNode(parent, &next_menu_id_);
+    if (show_supervised)
+      BuildMenuForSupervisedNode(parent, &next_menu_id_);
     BuildMenu(node, start_child_index, parent, &next_menu_id_);
     if (show_options == SHOW_PERMANENT_FOLDERS)
       BuildMenusForPermanentNodes(parent, &next_menu_id_);
   } else {
     menu_ = CreateMenu(node, start_child_index, show_options);
   }
 }
 
 void BookmarkMenuDelegate::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
@@ skipping 319 matching lines @@
 }
 
 MenuItemView* BookmarkMenuDelegate::CreateMenu(const BookmarkNode* parent,
                                                int start_child_index,
                                                ShowOptions show_options) {
   MenuItemView* menu = new MenuItemView(real_delegate_);
   menu->SetCommand(next_menu_id_++);
   menu_id_to_node_map_[menu->GetCommand()] = parent;
   menu->set_has_icons(true);
   bool show_permanent = show_options == SHOW_PERMANENT_FOLDERS;
-  if (show_permanent && parent == GetBookmarkModel()->bookmark_bar_node())
+  if (show_permanent && parent == GetBookmarkModel()->bookmark_bar_node()) {
     BuildMenuForManagedNode(menu, &next_menu_id_);
+    BuildMenuForSupervisedNode(menu, &next_menu_id_);
+  }
   BuildMenu(parent, start_child_index, menu, &next_menu_id_);
   if (show_permanent)
     BuildMenusForPermanentNodes(menu, &next_menu_id_);
   return menu;
 }
 
 void BookmarkMenuDelegate::BuildMenusForPermanentNodes(
     views::MenuItemView* menu,
     int* next_menu_id) {
   BookmarkModel* model = GetBookmarkModel();
@@ skipping 25 matching lines @@
   }
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia* folder_icon = rb->GetImageSkiaNamed(icon_resource_id);
   MenuItemView* submenu = menu->AppendSubMenuWithIcon(
       id, node->GetTitle(), *folder_icon);
   BuildMenu(node, 0, submenu, next_menu_id);
   menu_id_to_node_map_[id] = node;
 }
 
-void BookmarkMenuDelegate::BuildMenuForManagedNode(
-    MenuItemView* menu,
-    int* next_menu_id) {
+void BookmarkMenuDelegate::BuildMenuForManagedNode(MenuItemView* menu,
+                                                   int* next_menu_id) {
   // Don't add a separator for this menu.
   bool added_separator = true;
   const BookmarkNode* node = GetChromeBookmarkClient()->managed_node();
   BuildMenuForPermanentNode(node, IDR_BOOKMARK_BAR_FOLDER_MANAGED, menu,
                             next_menu_id, &added_separator);
 }
 
+void BookmarkMenuDelegate::BuildMenuForSupervisedNode(MenuItemView* menu,
+                                                      int* next_menu_id) {
+  // Don't add a separator for this menu.
+  bool added_separator = true;
+  const BookmarkNode* node = GetChromeBookmarkClient()->supervised_node();
+  BuildMenuForPermanentNode(node, IDR_BOOKMARK_BAR_FOLDER_SUPERVISED, menu,
+                            next_menu_id, &added_separator);
+}
+
 void BookmarkMenuDelegate::BuildMenu(const BookmarkNode* parent,
                                      int start_child_index,
                                      MenuItemView* menu,
                                      int* next_menu_id) {
   node_to_menu_map_[parent] = menu;
   DCHECK(parent->empty() || start_child_index < parent->child_count());
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   for (int i = start_child_index; i < parent->child_count(); ++i) {
     const BookmarkNode* node = parent->GetChild(i);
     const int id = *next_menu_id;
@@ skipping 18 matching lines @@
       BuildMenu(node, 0, submenu, next_menu_id);
     } else {
       NOTREACHED();
     }
   }
 }
 
 bool BookmarkMenuDelegate::IsOutsideMenuIdRange(int menu_id) const {
   return menu_id < min_menu_id_ || menu_id > max_menu_id_;
 }