Managed bookmarks for supervised users

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
 
 #include "base/mac/bundle_locations.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 202 matching lines @@
 // buttons showing. If too many then show the off-the-side list, if none
 // then show the no items label.
 - (void)reconfigureBookmarkBar;
 
 - (void)addNode:(const BookmarkNode*)child toMenu:(NSMenu*)menu;
 - (void)addFolderNode:(const BookmarkNode*)node toMenu:(NSMenu*)menu;
 - (void)tagEmptyMenu:(NSMenu*)menu;
 - (void)clearMenuTagMap;
 - (int)preferredHeight;
 - (void)addButtonsToView;
+- (BOOL)setBookmarkButtonVisibility;
 - (BOOL)setManagedBookmarksButtonVisibility;
+- (BOOL)setSupervisedBookmarksButtonVisibility;
 - (BOOL)setOtherBookmarksButtonVisibility;
 - (BOOL)setAppsPageShortcutButtonVisibility;
 - (BookmarkButton*)createCustomBookmarkButtonForCell:(NSCell*)cell;
 - (void)createManagedBookmarksButton;
+- (void)createSupervisedBookmarksButton;
 - (void)createOtherBookmarksButton;
 - (void)createAppsPageShortcutButton;
 - (void)openAppsPage:(id)sender;
 - (void)centerNoItemsLabel;
 - (void)positionRightSideButtons;
 - (void)watchForExitEvent:(BOOL)watch;
 - (void)resetAllButtonPositionsWithAnimation:(BOOL)animate;
 
 @end
 
@@ skipping 85 matching lines @@
   for (BookmarkButton* button in [self buttons]) {
     if ([button bookmarkNode] == node) {
       [button setIsContinuousPulsing:doPulse];
       return;
     }
   }
   if ([managedBookmarksButton_ bookmarkNode] == node) {
     [managedBookmarksButton_ setIsContinuousPulsing:doPulse];
     return;
   }
+  if ([supervisedBookmarksButton_ bookmarkNode] == node) {
+    [supervisedBookmarksButton_ setIsContinuousPulsing:doPulse];
+    return;
+  }
   if ([otherBookmarksButton_ bookmarkNode] == node) {
     [otherBookmarksButton_ setIsContinuousPulsing:doPulse];
     return;
   }
   if (node->parent() == bookmarkModel_->bookmark_bar_node()) {
     [offTheSideButton_ setIsContinuousPulsing:doPulse];
     return;
   }
 
   NOTREACHED() << "no bookmark button found to pulse!";
@@ skipping 151 matching lines @@
   [buttonView_ setFrame:buttonViewFrame];
 
   // Update bookmark button backgrounds.
   if ([self isAnimationRunning]) {
     for (NSButton* button in buttons_.get())
       [button setNeedsDisplay:YES];
     // Update the apps and other buttons explicitly, since they are not in the
     // buttons_ array.
     [appsPageShortcutButton_ setNeedsDisplay:YES];
     [managedBookmarksButton_ setNeedsDisplay:YES];
+    [supervisedBookmarksButton_ setNeedsDisplay:YES];
     [otherBookmarksButton_ setNeedsDisplay:YES];
   }
 }
 
 // We don't change a preference; we only change visibility. Preference changing
 // (global state) is handled in |chrome::ToggleBookmarkBarWhenVisible()|. We
 // simply update based on what we're told.
 - (void)updateVisibility {
   [self showBookmarkBarWithAnimation:NO];
 }
 
 - (void)updateExtraButtonsVisibility {
-  if (!appsPageShortcutButton_.get() || !managedBookmarksButton_.get())
+  if (!appsPageShortcutButton_.get() ||
+      !managedBookmarksButton_.get() ||
+      !supervisedBookmarksButton_.get()) {
     return;
+  }
   [self setAppsPageShortcutButtonVisibility];
   [self setManagedBookmarksButtonVisibility];
+  [self setSupervisedBookmarksButtonVisibility];
   [self resetAllButtonPositionsWithAnimation:NO];
   [self reconfigureBookmarkBar];
 }
 
 - (void)updateHiddenState {
   BOOL oldHidden = [[self view] isHidden];
   BOOL newHidden = ![self isVisible];
   if (oldHidden != newHidden)
     [[self view] setHidden:newHidden];
 }
@@ skipping 52 matching lines @@
 - (NSImage*)faviconForNode:(const BookmarkNode*)node {
   if (!node)
     return defaultImage_;
 
   if (node == bookmarkClient_->managed_node()) {
     // Most users never see this node, so the image is only loaded if needed.
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     return rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_FOLDER_MANAGED).ToNSImage();
   }
 
+  if (node == bookmarkClient_->supervised_node()) {
+    // Most users never see this node, so the image is only loaded if needed.
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    return rb.GetNativeImageNamed(
+        IDR_BOOKMARK_BAR_FOLDER_SUPERVISED).ToNSImage();
+  }
+
   if (node->is_folder())
     return folderImage_;
 
   const gfx::Image& favicon = bookmarkModel_->GetFavicon(node);
   if (!favicon.IsEmpty())
     return favicon.ToNSImage();
 
   return defaultImage_;
 }
 
@@ skipping 494 matching lines @@
 
   // Draw the managed bookmark folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
     xOffset += bookmarks::kBookmarkHorizontalPadding;
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[managedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [managedBookmarksButton_ setFrame:frame];
   }
 
+  // Draw the supervised bookmark folder if needed.
+  if (![supervisedBookmarksButton_ isHidden]) {
+    xOffset += bookmarks::kBookmarkHorizontalPadding;
+    NSRect frame =
+        [self frameForBookmarkButtonFromCell:[supervisedBookmarksButton_ cell]
+                                     xOffset:&xOffset];
+    [supervisedBookmarksButton_ setFrame:frame];
+  }
+
   for (int i = 0; i < node->child_count(); i++) {
     const BookmarkNode* child = node->GetChild(i);
     BookmarkButton* button = [self buttonForNode:child xOffset:&xOffset];
     if (NSMinX([button frame]) >= maxViewX) {
       [button setDelegate:nil];
       break;
     }
     [buttons_ addObject:button];
   }
 }
@@ skipping 63 matching lines @@
     ++displayedButtonCount_;
   }
   NSUInteger removalCount =
       [buttons count] - (NSUInteger)displayedButtonCount_;
   if (removalCount > 0) {
     NSRange removalRange = NSMakeRange(displayedButtonCount_, removalCount);
     [buttons removeObjectsInRange:removalRange];
   }
 }
 
-// Shows or hides the Other Bookmarks button as appropriate, and returns
+// Shows or hides the Managed, Supervised, or Other Bookmarks button as
+// appropriate, and returns whether it ended up visible.
+- (BOOL)setBookmarkButtonVisibility:(BookmarkButton*)button
+                            canShow:(BOOL)show
+            resetAllButtonPositions:(BOOL)resetButtons {
+  if (!button)
+    return NO;
+
+  BOOL visible = ![button bookmarkNode]->empty() && show;
+  BOOL currentVisibility = ![button isHidden];
+  if (currentVisibility != visible) {
+    [button setHidden:!visible];
+    if (resetButtons)
+      [self resetAllButtonPositionsWithAnimation:NO];
+  }
+  return visible;
+}
+
+// Shows or hides the Managed Bookmarks button as appropriate, and returns
 // whether it ended up visible.
 - (BOOL)setManagedBookmarksButtonVisibility {
-  if (!managedBookmarksButton_.get())
-    return NO;
+  PrefService* prefs = browser_->profile()->GetPrefs();
+  BOOL prefIsSet =
+      prefs->GetBoolean(bookmarks::prefs::kShowManagedBookmarksInBookmarkBar);
+  return [self setBookmarkButtonVisibility:managedBookmarksButton_.get()
+                                   canShow:prefIsSet
+                   resetAllButtonPositions:YES];
+}
 
-  PrefService* prefs = browser_->profile()->GetPrefs();
-  BOOL visible =
-      ![managedBookmarksButton_ bookmarkNode]->empty() &&
-      prefs->GetBoolean(bookmarks::prefs::kShowManagedBookmarksInBookmarkBar);
-  BOOL currentVisibility = ![managedBookmarksButton_ isHidden];
-  if (currentVisibility != visible) {
-    [managedBookmarksButton_ setHidden:!visible];
-    [self resetAllButtonPositionsWithAnimation:NO];
-  }
-  return visible;
+// Shows or hides the Supervised Bookmarks button as appropriate, and returns
+// whether it ended up visible.
+- (BOOL)setSupervisedBookmarksButtonVisibility {
+  return [self setBookmarkButtonVisibility:supervisedBookmarksButton_.get()
+                                   canShow:YES
+                   resetAllButtonPositions:YES];
 }
 
 // Shows or hides the Other Bookmarks button as appropriate, and returns
 // whether it ended up visible.
 - (BOOL)setOtherBookmarksButtonVisibility {
-  if (!otherBookmarksButton_.get())
-    return NO;
-
-  BOOL visible = ![otherBookmarksButton_ bookmarkNode]->empty();
-  [otherBookmarksButton_ setHidden:!visible];
-  return visible;
+  return [self setBookmarkButtonVisibility:otherBookmarksButton_.get()
+                                   canShow:YES
+                   resetAllButtonPositions:NO];
 }
 
 // Shows or hides the Apps button as appropriate, and returns whether it ended
 // up visible.
 - (BOOL)setAppsPageShortcutButtonVisibility {
   if (!appsPageShortcutButton_.get())
     return NO;
 
   BOOL visible = bookmarkModel_->loaded() &&
       chrome::ShouldShowAppsShortcutInBookmarkBar(
@@ skipping 35 matching lines @@
 
   NSCell* cell = [self cellForBookmarkNode:bookmarkClient_->managed_node()];
   managedBookmarksButton_.reset([self createCustomBookmarkButtonForCell:cell]);
   [managedBookmarksButton_ setAction:@selector(openBookmarkFolderFromButton:)];
   view_id_util::SetID(managedBookmarksButton_.get(), VIEW_ID_MANAGED_BOOKMARKS);
   [buttonView_ addSubview:managedBookmarksButton_.get()];
 
   [self setManagedBookmarksButtonVisibility];
 }
 
+// Creates the button for "Supervised Bookmarks", but does not position it.
+- (void)createSupervisedBookmarksButton {
+  if (supervisedBookmarksButton_.get()) {
+    // The button's already there, but its visibility may have changed.
+    [self setSupervisedBookmarksButtonVisibility];
+    return;
+  }
+
+  NSCell* cell = [self cellForBookmarkNode:bookmarkClient_->supervised_node()];
+  supervisedBookmarksButton_.reset(
+      [self createCustomBookmarkButtonForCell:cell]);
+  [supervisedBookmarksButton_
+      setAction:@selector(openBookmarkFolderFromButton:)];
+  view_id_util::SetID(supervisedBookmarksButton_.get(),
+                      VIEW_ID_SUPERVISED_BOOKMARKS);
+  [buttonView_ addSubview:supervisedBookmarksButton_.get()];
+
+  [self setSupervisedBookmarksButtonVisibility];
+}
+
 // Creates the button for "Other Bookmarks", but does not position it.
 - (void)createOtherBookmarksButton {
   // Can't create this until the model is loaded, but only need to
   // create it once.
   if (otherBookmarksButton_.get()) {
     [self setOtherBookmarksButtonVisibility];
     return;
   }
 
   NSCell* cell = [self cellForBookmarkNode:bookmarkModel_->other_node()];
@@ skipping 136 matching lines @@
 }
 
 // Delegate method for |AnimatableView| (a superclass of
 // |BookmarkBarToolbarView|).
 - (void)animationDidEnd:(NSAnimation*)animation {
   [self finalizeState];
 }
 
 - (void)reconfigureBookmarkBar {
   [self setManagedBookmarksButtonVisibility];
+  [self setSupervisedBookmarksButtonVisibility];
   [self redistributeButtonsOnBarAsNeeded];
   [self positionRightSideButtons];
   [self configureOffTheSideButtonContentsAndVisibility];
   [self centerNoItemsLabel];
 }
 
 // Determine if the given |view| can completely fit within the constraint of
 // maximum x, given by |maxViewX|, and, if not, narrow the view up to a minimum
 // width. If the minimum width is not achievable then hide the view. Return YES
 // if the view was hidden.
@@ skipping 52 matching lines @@
     if (![appsPageShortcutButton_ isHidden]) {
       float width = NSWidth([appsPageShortcutButton_ frame]);
       noItemsRect.origin.x += width;
       importBookmarksRect.origin.x += width;
     }
     if (![managedBookmarksButton_ isHidden]) {
       float width = NSWidth([managedBookmarksButton_ frame]);
       noItemsRect.origin.x += width;
       importBookmarksRect.origin.x += width;
     }
+    if (![supervisedBookmarksButton_ isHidden]) {
+      float width = NSWidth([supervisedBookmarksButton_ frame]);
+      noItemsRect.origin.x += width;
+      importBookmarksRect.origin.x += width;
+    }
     [noItemTextfield setFrame:noItemsRect];
     [noItemTextfield setHidden:NO];
     NSButton* importBookmarksButton = [buttonView_ importBookmarksButton];
     [importBookmarksButton setFrame:importBookmarksRect];
     [importBookmarksButton setHidden:NO];
     // Check each to see if they need to be shrunk or hidden.
     if ([self shrinkOrHideView:importBookmarksButton forMaxX:maxViewX])
       [self shrinkOrHideView:noItemTextfield forMaxX:maxViewX];
   }
 }
@@ skipping 12 matching lines @@
     left = NSMaxX([appsPageShortcutButton_ frame]) +
         bookmarks::kBookmarkHorizontalPadding;
   }
 
   // Draw the managed bookmarks folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
     left = NSMaxX([managedBookmarksButton_ frame]) +
         bookmarks::kBookmarkHorizontalPadding;
   }
 
+  // Draw the supervised bookmarks folder if needed.
+  if (![supervisedBookmarksButton_ isHidden]) {
+    left = NSMaxX([supervisedBookmarksButton_ frame]) +
+        bookmarks::kBookmarkHorizontalPadding;
+  }
+
   for (NSButton* button in buttons_.get()) {
     // Hidden buttons get no space.
     if ([button isHidden])
       continue;
     buttonFrame = [button frame];
     buttonFrame.origin.x = left;
     left += buttonFrame.size.width + bookmarks::kBookmarkHorizontalPadding;
     if (button == wantedButton)
       return buttonFrame;
   }
@@ skipping 55 matching lines @@
 
   // As a result of cutting, deleting and dragging, the bar may now have room
   // for more buttons.
   int xOffset;
   if (displayedButtonCount_ > 0) {
     xOffset = NSMaxX([self finalRectOfLastButton]) +
         bookmarks::kBookmarkHorizontalPadding;
   } else if (![managedBookmarksButton_ isHidden]) {
     xOffset = NSMaxX([managedBookmarksButton_ frame]) +
         bookmarks::kBookmarkHorizontalPadding;
+  } else if (![supervisedBookmarksButton_ isHidden]) {
+    xOffset = NSMaxX([supervisedBookmarksButton_ frame]) +
+        bookmarks::kBookmarkHorizontalPadding;
   } else if (![appsPageShortcutButton_ isHidden]) {
     xOffset = NSMaxX([appsPageShortcutButton_ frame]) +
         bookmarks::kBookmarkHorizontalPadding;
   } else {
     xOffset = bookmarks::kBookmarkLeftMargin -
         bookmarks::kBookmarkHorizontalPadding;
   }
   for (int i = displayedButtonCount_; i < barCount; ++i) {
     const BookmarkNode* child = node->GetChild(i);
     BookmarkButton* button = [self buttonForNode:child xOffset:&xOffset];
@@ skipping 187 matching lines @@
 - (void)updateTheme:(ui::ThemeProvider*)themeProvider {
   if (!themeProvider)
     return;
   NSColor* color =
       themeProvider->GetNSColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
   for (BookmarkButton* button in buttons_.get()) {
     BookmarkButtonCell* cell = [button cell];
     [cell setTextColor:color];
   }
   [[managedBookmarksButton_ cell] setTextColor:color];
+  [[supervisedBookmarksButton_ cell] setTextColor:color];
   [[otherBookmarksButton_ cell] setTextColor:color];
   [[appsPageShortcutButton_ cell] setTextColor:color];
 }
 
 // Return YES if the event indicates an exit from the bookmark bar
 // folder menus.  E.g. "click outside" of the area we are watching.
 // At this time we are watching the area that includes all popup
 // bookmark folder windows.
 - (BOOL)isEventAnExitEvent:(NSEvent*)event {
   NSWindow* eventWindow = [event window];
@@ skipping 209 matching lines @@
 }
 
 // Set insertionPos_ and hasInsertionPos_, and make insertion space for a
 // hypothetical drop with the new button having a left edge of |where|.
 // Gets called only by our view.
 - (void)setDropInsertionPos:(CGFloat)where {
   if (!hasInsertionPos_ || where != insertionPos_) {
     insertionPos_ = where;
     hasInsertionPos_ = YES;
     CGFloat left;
-    if (![managedBookmarksButton_ isHidden]) {
+    if (![supervisedBookmarksButton_ isHidden]) {
+      left = NSMaxX([supervisedBookmarksButton_ frame]) +
+             bookmarks::kBookmarkHorizontalPadding;
+    } else if (![managedBookmarksButton_ isHidden]) {
       left = NSMaxX([managedBookmarksButton_ frame]) +
              bookmarks::kBookmarkHorizontalPadding;
     } else if (![appsPageShortcutButton_ isHidden]) {
       left = NSMaxX([appsPageShortcutButton_ frame]) +
              bookmarks::kBookmarkHorizontalPadding;
     } else {
       left = bookmarks::kBookmarkLeftMargin;
     }
     CGFloat paddingWidth = bookmarks::kDefaultBookmarkWidth;
     BookmarkButton* draggedButton = [BookmarkButton draggedButton];
@@ skipping 46 matching lines @@
   // Position the managed bookmarks folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
     int xOffset = left;
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[managedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [managedBookmarksButton_ setFrame:frame];
     left = xOffset + bookmarks::kBookmarkHorizontalPadding;
   }
 
+  // Position the supervised bookmarks folder if needed.
+  if (![supervisedBookmarksButton_ isHidden]) {
+    int xOffset = left;
+    NSRect frame =
+        [self frameForBookmarkButtonFromCell:[supervisedBookmarksButton_ cell]
+                                     xOffset:&xOffset];
+    [supervisedBookmarksButton_ setFrame:frame];
+    left = xOffset + bookmarks::kBookmarkHorizontalPadding;
+  }
+
   animate &= innerContentAnimationsEnabled_;
 
   for (NSButton* button in buttons_.get()) {
     // Hidden buttons get no space.
     if ([button isHidden])
       continue;
     NSRect buttonFrame = [button frame];
     buttonFrame.origin.x = left;
     left += buttonFrame.size.width + bookmarks::kBookmarkHorizontalPadding;
     if (animate)
@@ skipping 27 matching lines @@
   // See: http://crbug.com/36614
   if (folderController_)
     [self closeAllBookmarkFolders];
 
   // Brute force nuke and build.
   savedFrameWidth_ = NSWidth([[self view] frame]);
   const BookmarkNode* node = model->bookmark_bar_node();
   [self clearBookmarkBar];
   [self createAppsPageShortcutButton];
   [self createManagedBookmarksButton];
+  [self createSupervisedBookmarksButton];
   [self addNodesToButtonList:node];
   [self createOtherBookmarksButton];
   [self updateTheme:[[[self view] window] themeProvider]];
   [self positionRightSideButtons];
   [self addButtonsToView];
   [self configureOffTheSideButtonContentsAndVisibility];
   [self reconfigureBookmarkBar];
 }
 
 - (void)beingDeleted:(BookmarkModel*)model {
@@ skipping 384 matching lines @@
 }
 
 // Return the x position for a drop indicator.
 - (CGFloat)indicatorPosForDragToPoint:(NSPoint)point {
   CGFloat x = 0;
   CGFloat halfHorizontalPadding = 0.5 * bookmarks::kBookmarkHorizontalPadding;
   int destIndex = [self indexForDragToPoint:point];
   int numButtons = displayedButtonCount_;
 
   CGFloat leftmostX;
-  if (![managedBookmarksButton_ isHidden])
+  if (![supervisedBookmarksButton_ isHidden]) {
+    leftmostX =
+        NSMaxX([supervisedBookmarksButton_ frame]) + halfHorizontalPadding;
+  } else if (![managedBookmarksButton_ isHidden]) {
     leftmostX = NSMaxX([managedBookmarksButton_ frame]) + halfHorizontalPadding;
-  else if (![appsPageShortcutButton_ isHidden])
+  } else if (![appsPageShortcutButton_ isHidden]) {
     leftmostX = NSMaxX([appsPageShortcutButton_ frame]) + halfHorizontalPadding;
-  else
+  } else {
     leftmostX = bookmarks::kBookmarkLeftMargin - halfHorizontalPadding;
+  }
 
   // If it's a drop strictly between existing buttons ...
   if (destIndex == 0) {
     x = leftmostX;
   } else if (destIndex > 0 && destIndex < numButtons) {
     // ... put the indicator right between the buttons.
     BookmarkButton* button =
         [buttons_ objectAtIndex:static_cast<NSUInteger>(destIndex-1)];
     DCHECK(button);
     NSRect buttonFrame = [button frame];
@@ skipping 231 matching lines @@
 - (id<BookmarkButtonControllerProtocol>)controllerForNode:
     (const BookmarkNode*)node {
   // See if it's in the bar, then if it is in the hierarchy of visible
   // folder menus.
   if (bookmarkModel_->bookmark_bar_node() == node)
     return self;
   return [folderController_ controllerForNode:node];
 }
 
 @end