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 33 matching lines @@
 #include "chrome/browser/ui/views/event_utils.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/metrics/metrics_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
@@ skipping 86 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()) {
+    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 175 matching lines @@
     parent_on_bb = parent;
   }
   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)) {
+  } else if (bookmarks::IsDescendantOf(node, client_->managed_node())) {
     throbbing_view_ = managed_bookmarks_button_;
+  } else if (bookmarks::IsDescendantOf(node, client_->supervised_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 10 matching lines @@
     }
     old_node = parent;
   }
   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))
+  if (bookmarks::IsDescendantOf(parent, client_->managed_node()))
     return managed_bookmarks_button_;
+  if (bookmarks::IsDescendantOf(parent, client_->supervised_node()))
+    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();
 }