Managed bookmarks for supervised users

chrome/browser/ui/views/bookmarks/bookmark_bar_view.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_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 138 matching lines @@
 
 // Tag for the 'Apps Shortcut' button.
 static const int kAppsShortcutButtonTag = 2;
 
 // Preferred padding between text and edge.
 static const int kButtonPaddingHorizontal = 6;
 static const int kButtonPaddingVertical = 4;
 
 // Tag for the 'Managed bookmarks' button.
 static const int kManagedFolderButtonTag = 3;
+// Tag for the 'Supervised bookmarks' button.
+static const int kSupervisedFolderButtonTag = 4;
 
 #if !defined(OS_WIN)
 static const gfx::ElideBehavior kElideBehavior = gfx::FADE_TAIL;
 #else
 // Windows fade eliding causes text to darken; see http://crbug.com/388084
 static const gfx::ElideBehavior kElideBehavior = gfx::ELIDE_TAIL;
 #endif
 
 namespace {
 
@@ skipping 324 matching lines @@
 // static
 const char BookmarkBarView::kViewClassName[] = "BookmarkBarView";
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
       client_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarks_button_(NULL),
       managed_bookmarks_button_(NULL),
+      supervised_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false),
@@ skipping 81 matching lines @@
     return NULL;
 
   gfx::Point adjusted_loc(GetMirroredXInView(loc.x()), loc.y());
 
   // Check the managed button first.
   if (managed_bookmarks_button_->visible() &&
       managed_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return client_->managed_node();
   }
 
+  // Then check the supervised button.
+  if (supervised_bookmarks_button_->visible() &&
+      supervised_bookmarks_button_->bounds().Contains(adjusted_loc)) {
+    return client_->supervised_node();
+  }
+
   // Then check the bookmark buttons.
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
       break;
     if (child->bounds().Contains(adjusted_loc))
       return model_->bookmark_bar_node()->GetChild(i);
   }
 
   // Then the overflow button.
   if (overflow_button_->visible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *model_start_index = GetFirstHiddenNodeIndex();
     return model_->bookmark_bar_node();
   }
 
   // And finally the other folder.
   if (other_bookmarks_button_->visible() &&
       other_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return model_->other_node();
   }
 
   return NULL;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == client_->managed_node())
     return managed_bookmarks_button_;
+  if (node == client_->supervised_node())
+    return supervised_bookmarks_button_;
   if (node == model_->other_node())
     return other_bookmarks_button_;
   if (node == model_->bookmark_bar_node())
     return overflow_button_;
   int index = model_->bookmark_bar_node()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
     return NULL;
   return static_cast<views::MenuButton*>(child_at(index));
 }
 
@@ skipping 123 matching lines @@
           popup_model()->IsOpen()) {
     return false;
   }
   return true;
 }
 
 gfx::Size BookmarkBarView::GetMinimumSize() const {
   // The minimum width of the bookmark bar should at least contain the overflow
   // button, by which one can access all the Bookmark Bar items, and the "Other
   // Bookmarks" folder, along with appropriate margins and button padding.
-  // It should also contain the Managed Bookmarks folder, if it's visible.
+  // It should also contain the Managed and/or Supervised Bookmarks folders,
+  // if they are visible.
   int width = kLeftMargin;
 
   int height = chrome::kBookmarkBarHeight;
   if (IsDetached()) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(kNewTabHorizontalPadding * current_state);
     height += static_cast<int>(
         (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
             current_state);
   }
 
   if (managed_bookmarks_button_->visible()) {
     gfx::Size size = managed_bookmarks_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
+  if (supervised_bookmarks_button_->visible()) {
+    gfx::Size size = supervised_bookmarks_button_->GetPreferredSize();
+    width += size.width() + kButtonPadding;
+  }
   if (other_bookmarks_button_->visible()) {
     gfx::Size size = other_bookmarks_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
   if (overflow_button_->visible()) {
     gfx::Size size = overflow_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
   if (bookmarks_separator_view_->visible()) {
     gfx::Size size = bookmarks_separator_view_->GetPreferredSize();
@@ skipping 47 matching lines @@
 
   // Start with the apps page shortcut button.
   if (apps_page_shortcut_->visible()) {
     apps_page_shortcut_->SetBounds(x, y, apps_page_shortcut_pref.width(),
                                    height);
     x += apps_page_shortcut_pref.width() + kButtonPadding;
   }
 
   // Then comes the managed bookmarks folder, if visible.
   if (managed_bookmarks_button_->visible()) {
-    gfx::Size managed_bookmarks_pref = managed_bookmarks_button_->visible() ?
-        managed_bookmarks_button_->GetPreferredSize() : gfx::Size();
+    gfx::Size managed_bookmarks_pref =
+        managed_bookmarks_button_->GetPreferredSize();
     managed_bookmarks_button_->SetBounds(x, y, managed_bookmarks_pref.width(),
                                          height);
     x += managed_bookmarks_pref.width() + kButtonPadding;
   }
 
+  // Then the supervised bookmarks folder, if visible.
+  if (supervised_bookmarks_button_->visible()) {

[sky, 2015/02/04 18:36:58]

What happens when the supervised, managed and apps shortcut are all visible and
the window is made as narrow as possible?

[Marc Treib, 2015/02/05 12:57:06]

We're only exposing the supervised bookmarks for child accounts right now, which
can't also be dasher accounts, so the managed and supervised folders won't show
up at the same time.
That said: Chrome's current behavior is that it won't allow the window to get so
narrow that the supervised folder wouldn't fit.

[sky, 2015/02/05 17:57:11]

Ok.

+    gfx::Size supervised_bookmarks_pref =
+        supervised_bookmarks_button_->GetPreferredSize();
+    supervised_bookmarks_button_->SetBounds(
+        x, y, supervised_bookmarks_pref.width(), height);
+    x += supervised_bookmarks_pref.width() + kButtonPadding;
+  }
+
   const bool show_instructions =
       model_ && model_->loaded() &&
       model_->bookmark_bar_node()->child_count() == 0;
   instructions_->SetVisible(show_instructions);
   if (show_instructions) {
     gfx::Size pref = instructions_->GetPreferredSize();
     instructions_->SetBounds(
         x + kInstructionsPadding, y,
         std::min(static_cast<int>(pref.width()),
                  max_x - x),
@@ skipping 323 matching lines @@
   // There should be no buttons. If non-zero it means Load was invoked more than
   // once, or we didn't properly clear things. Either of which shouldn't happen.
   // The actual bookmark buttons are added from Layout().
   DCHECK_EQ(0, GetBookmarkButtonCount());
   DCHECK(model->other_node());
   other_bookmarks_button_->SetAccessibleName(model->other_node()->GetTitle());
   other_bookmarks_button_->SetText(model->other_node()->GetTitle());
   managed_bookmarks_button_->SetAccessibleName(
       client_->managed_node()->GetTitle());
   managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
+  supervised_bookmarks_button_->SetAccessibleName(
+      client_->supervised_node()->GetTitle());
+  supervised_bookmarks_button_->SetText(client_->supervised_node()->GetTitle());
   UpdateColors();
   UpdateOtherAndManagedButtonsVisibility();
   other_bookmarks_button_->SetEnabled(true);
   managed_bookmarks_button_->SetEnabled(true);
+  supervised_bookmarks_button_->SetEnabled(true);
   LayoutAndPaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
   model_ = NULL;
 }
 
@@ skipping 154 matching lines @@
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
   if (view == other_bookmarks_button_) {
     node = model_->other_node();
   } else if (view == managed_bookmarks_button_) {
     node = client_->managed_node();
+  } else if (view == supervised_bookmarks_button_) {
+    node = client_->supervised_node();
   } else if (view == overflow_button_) {
     node = model_->bookmark_bar_node();
     start_index = GetFirstHiddenNodeIndex();
   } else {
     int button_index = GetIndexOf(view);
     DCHECK_NE(-1, button_index);
     node = model_->bookmark_bar_node()->GetChild(button_index);
   }
 
   RecordBookmarkFolderOpen(GetBookmarkLaunchLocation());
@@ skipping 17 matching lines @@
     page_navigator_->OpenURL(params);
     RecordBookmarkAppsPageOpen(GetBookmarkLaunchLocation());
     return;
   }
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else if (sender->tag() == kManagedFolderButtonTag) {
     node = client_->managed_node();
+  } else if (sender->tag() == kSupervisedFolderButtonTag) {
+    node = client_->supervised_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
   if (node->is_url()) {
     RecordAppLaunch(browser_->profile(), node->url());
     OpenURLParams params(
@@ skipping 19 matching lines @@
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarks_button_) {
     parent = model_->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
     // sure the user can't edit/delete the node in this case.
     nodes.push_back(parent);
   } else if (source == managed_bookmarks_button_) {
     parent = client_->managed_node();
     nodes.push_back(parent);
+  } else if (source == supervised_bookmarks_button_) {
+    parent = client_->supervised_node();
+    nodes.push_back(parent);
   } else if (source != this && source != apps_page_shortcut_) {
     // User clicked on one of the bookmark buttons, find which one they
     // clicked on, except for the apps page shortcut, which must behave as if
     // the user clicked on the bookmark bar background.
     int bookmark_button_index = GetIndexOf(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     const BookmarkNode* node =
         model_->bookmark_bar_node()->GetChild(bookmark_button_index);
     nodes.push_back(node);
@@ skipping 26 matching lines @@
   other_bookmarks_button_ = CreateOtherBookmarksButton();
   // We'll re-enable when the model is loaded.
   other_bookmarks_button_->SetEnabled(false);
   AddChildView(other_bookmarks_button_);
 
   managed_bookmarks_button_ = CreateManagedBookmarksButton();
   // Also re-enabled when the model is loaded.
   managed_bookmarks_button_->SetEnabled(false);
   AddChildView(managed_bookmarks_button_);
 
+  supervised_bookmarks_button_ = CreateSupervisedBookmarksButton();
+  // Also re-enabled when the model is loaded.
+  supervised_bookmarks_button_->SetEnabled(false);
+  AddChildView(supervised_bookmarks_button_);
+
   apps_page_shortcut_ = CreateAppsPageShortcutButton();
   AddChildView(apps_page_shortcut_);
   profile_pref_registrar_.Init(browser_->profile()->GetPrefs());
   profile_pref_registrar_.Add(
       bookmarks::prefs::kShowAppsShortcutInBookmarkBar,
       base::Bind(&BookmarkBarView::OnAppsPageShortcutVisibilityPrefChanged,
                  base::Unretained(this)));
   profile_pref_registrar_.Add(
       bookmarks::prefs::kShowManagedBookmarksInBookmarkBar,
       base::Bind(&BookmarkBarView::OnShowManagedBookmarksPrefChanged,
@@ skipping 18 matching lines @@
   if (model_) {
     model_->AddObserver(this);
     if (model_->loaded())
       BookmarkModelLoaded(model_, false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() const {
-  // We contain six non-bookmark button views: managed bookmarks,
-  // other bookmarks, bookmarks separator, chevrons (for overflow), apps page,
-  // and the instruction label.
-  return child_count() - 6;
+  // We contain seven non-bookmark button views: managed bookmarks, supervised
+  // bookmarks, other bookmarks, bookmarks separator, chevrons (for overflow),
+  // apps page, and the instruction label.
+  return child_count() - 7;
 }
 
 views::LabelButton* BookmarkBarView::GetBookmarkButton(int index) {
   // CHECK as otherwise we may do the wrong cast.
   CHECK(index >= 0 && index < GetBookmarkButtonCount());
   return static_cast<views::LabelButton*>(child_at(index));
 }
 
 BookmarkLaunchLocation BookmarkBarView::GetBookmarkLaunchLocation() const {
   return IsDetached() ? BOOKMARK_LAUNCH_LOCATION_DETACHED_BAR :
@@ skipping 26 matching lines @@
   MenuButton* button =
       new BookmarkFolderButton(this, base::string16(), this, false);
   button->set_id(VIEW_ID_MANAGED_BOOKMARKS);
   button->SetImage(views::Button::STATE_NORMAL,
                    *GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER_MANAGED));
   button->set_context_menu_controller(this);
   button->set_tag(kManagedFolderButtonTag);
   return button;
 }
 
+MenuButton* BookmarkBarView::CreateSupervisedBookmarksButton() {
+  // Title is set in Loaded.
+  MenuButton* button =
+      new BookmarkFolderButton(this, base::string16(), this, false);
+  button->set_id(VIEW_ID_SUPERVISED_BOOKMARKS);
+  button->SetImage(views::Button::STATE_NORMAL,
+                   *GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER_SUPERVISED));
+  button->set_context_menu_controller(this);
+  button->set_tag(kSupervisedFolderButtonTag);
+  return button;
+}
+
 MenuButton* BookmarkBarView::CreateOverflowButton() {
   MenuButton* button = new OverFlowButton(this);
   button->SetImage(views::Button::STATE_NORMAL,
                    *GetImageSkiaNamed(IDR_BOOKMARK_BAR_CHEVRONS));
 
   // The overflow button's image contains an arrow and therefore it is a
   // direction sensitive image and we need to flip it if the UI layout is
   // right-to-left.
   //
   // By default, menu buttons are not flipped because they generally contain
@@ skipping 100 matching lines @@
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               const BookmarkNode* node) {
   if (node == client_->managed_node()) {
     // The managed node may have its title updated.
     managed_bookmarks_button_->SetAccessibleName(
         client_->managed_node()->GetTitle());
     managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
     return;
   }
+  if (node == client_->supervised_node()) {
+    // The supervised node may have its title updated.
+    supervised_bookmarks_button_->SetAccessibleName(
+        client_->supervised_node()->GetTitle());
+    supervised_bookmarks_button_->SetText(
+        client_->supervised_node()->GetTitle());
+    return;
+  }
 
   if (node->parent() != model->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model->bookmark_bar_node()->GetIndexOf(node);
   DCHECK_NE(-1, index);
   if (index >= GetBookmarkButtonCount())
     return;  // Buttons are created as needed.
   views::LabelButton* button = GetBookmarkButton(index);
@@ skipping 177 matching lines @@
   if (parent_on_bb) {
     int index = bbn->GetIndexOf(parent_on_bb);
     if (index >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       throbbing_view_ = overflow_button_;
     } else if (!overflow_only) {
       throbbing_view_ = static_cast<CustomButton*>(child_at(index));
     }
   } else if (client_->IsDescendantOfManagedNode(node)) {
     throbbing_view_ = managed_bookmarks_button_;
+  } else if (client_->IsDescendantOfSupervisedNode(node)) {
+    throbbing_view_ = supervised_bookmarks_button_;
   } else if (!overflow_only) {
     throbbing_view_ = other_bookmarks_button_;
   }
 
   // Use a large number so that the button continues to throb.
   if (throbbing_view_)
     throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 views::CustomButton* BookmarkBarView::DetermineViewToThrobFromRemove(
@@ skipping 12 matching lines @@
   }
   if (old_node) {
     if (old_index_on_bb >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       return overflow_button_;
     }
     return static_cast<CustomButton*>(child_at(old_index_on_bb));
   }
   if (client_->IsDescendantOfManagedNode(parent))
     return managed_bookmarks_button_;
+  if (client_->IsDescendantOfSupervisedNode(parent))
+    return supervised_bookmarks_button_;
   // Node wasn't on the bookmark bar, use the "Other Bookmarks" button.
   return other_bookmarks_button_;
 }
 
 void BookmarkBarView::UpdateColors() {
   // We don't always have a theme provider (ui tests, for example).
   const ui::ThemeProvider* theme_provider = GetThemeProvider();
   if (!theme_provider)
     return;
   SkColor color =
       theme_provider->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetTextColor(views::Button::STATE_NORMAL, color);
   other_bookmarks_button_->SetTextColor(views::Button::STATE_NORMAL, color);
   managed_bookmarks_button_->SetTextColor(views::Button::STATE_NORMAL, color);
+  supervised_bookmarks_button_->SetTextColor(views::Button::STATE_NORMAL,
+                                             color);
   if (apps_page_shortcut_->visible())
     apps_page_shortcut_->SetTextColor(views::Button::STATE_NORMAL, color);
 }
 
 bool BookmarkBarView::UpdateOtherAndManagedButtonsVisibility() {
   bool has_other_children = !model_->other_node()->empty();
   bool update_other = has_other_children != other_bookmarks_button_->visible();
   if (update_other) {
     other_bookmarks_button_->SetVisible(has_other_children);
     UpdateBookmarksSeparatorVisibility();
   }
 
   bool show_managed = !client_->managed_node()->empty() &&
                       browser_->profile()->GetPrefs()->GetBoolean(
                           bookmarks::prefs::kShowManagedBookmarksInBookmarkBar);
   bool update_managed = show_managed != managed_bookmarks_button_->visible();
   if (update_managed)
     managed_bookmarks_button_->SetVisible(show_managed);
 
-  return update_other || update_managed;
+  bool show_supervised = !client_->supervised_node()->empty();
+  bool update_supervised =
+      show_supervised != supervised_bookmarks_button_->visible();
+  if (update_supervised)
+    supervised_bookmarks_button_->SetVisible(show_supervised);
+
+  return update_other || update_managed || update_supervised;
 }
 
 void BookmarkBarView::UpdateBookmarksSeparatorVisibility() {
   // Ash does not paint the bookmarks separator line because it looks odd on
   // the flat background.  We keep it present for layout, but don't draw it.
   bookmarks_separator_view_->SetVisible(
       browser_->host_desktop_type() != chrome::HOST_DESKTOP_TYPE_ASH &&
       other_bookmarks_button_->visible());
 }
 
 void BookmarkBarView::OnAppsPageShortcutVisibilityPrefChanged() {
   DCHECK(apps_page_shortcut_);
   // Only perform layout if required.
   bool visible = chrome::ShouldShowAppsShortcutInBookmarkBar(
       browser_->profile(), browser_->host_desktop_type());
   if (apps_page_shortcut_->visible() == visible)
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   LayoutAndPaint();
 }
 
 void BookmarkBarView::OnShowManagedBookmarksPrefChanged() {
   if (UpdateOtherAndManagedButtonsVisibility())
     LayoutAndPaint();
 }