Show the Managed Bookmarks folder in the views UI.

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 <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar_constants.h"
 #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h"
@@ skipping 99 matching lines @@
 
 // Left-padding for the instructional text.
 static const int kInstructionsPadding = 6;
 
 // Tag for the 'Other bookmarks' button.
 static const int kOtherFolderButtonTag = 1;
 
 // Tag for the 'Apps Shortcut' button.
 static const int kAppsShortcutButtonTag = 2;
 
+// Tag for the 'Managed bookmarks' button.
+static const int kManagedFolderButtonTag = 3;
+
 namespace {
 
 // To enable/disable BookmarkBar animations during testing. In production
 // animations are enabled by default.
 bool animations_enabled = true;
 
 // BookmarkButtonBase -----------------------------------------------
 
 // Base class for text buttons used on the bookmark bar.
 
@@ skipping 281 matching lines @@
   if (!kFolderIcon) {
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     kFolderIcon = rb->GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER);
   }
   return *kFolderIcon;
 }
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
       model_(NULL),
+      client_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
+      managed_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       show_folder_method_factory_(this),
       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),
@@ skipping 67 matching lines @@
 const BookmarkNode* BookmarkBarView::GetNodeForButtonAtModelIndex(
     const gfx::Point& loc,
     int* model_start_index) {
   *model_start_index = 0;
 
   if (loc.x() < 0 || loc.x() >= width() || loc.y() < 0 || loc.y() >= height())
     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();
+  }
+
   // Check the buttons first.
   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_bookmarked_button_->visible() &&
       other_bookmarked_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 == model_->other_node())
     return other_bookmarked_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.
   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);
   }
 
-  gfx::Size other_bookmarked_pref;
-  if (other_bookmarked_button_->visible())
-    other_bookmarked_pref = other_bookmarked_button_->GetPreferredSize();
-  gfx::Size overflow_pref;
-  if (overflow_button_->visible())
-    overflow_pref = overflow_button_->GetPreferredSize();
-  gfx::Size bookmarks_separator_pref;
-  if (bookmarks_separator_view_->visible())
-    bookmarks_separator_pref = bookmarks_separator_view_->GetPreferredSize();
-
-  gfx::Size apps_page_shortcut_pref;
-  if (apps_page_shortcut_->visible())
-    apps_page_shortcut_pref = apps_page_shortcut_->GetPreferredSize();
-  width += other_bookmarked_pref.width() + kButtonPadding +
-      apps_page_shortcut_pref.width() + kButtonPadding +
-      overflow_pref.width() + kButtonPadding +
-      bookmarks_separator_pref.width();
+  gfx::Size size;

[sky, 2014/06/05 23:46:47]

Make this local to each block.

[Joao da Silva, 2014/06/06 15:41:03]

Done.

+  if (managed_bookmarks_button_->visible()) {
+    size = managed_bookmarks_button_->GetPreferredSize();
+    width += size.width() + kButtonPadding;
+  }
+  if (other_bookmarked_button_->visible()) {
+    size = other_bookmarked_button_->GetPreferredSize();
+    width += size.width() + kButtonPadding;
+  }
+  if (overflow_button_->visible()) {
+    size = overflow_button_->GetPreferredSize();
+    width += size.width() + kButtonPadding;
+  }
+  if (bookmarks_separator_view_->visible()) {
+    size = bookmarks_separator_view_->GetPreferredSize();
+    width += size.width();
+  }
+  if (apps_page_shortcut_->visible()) {
+    size = apps_page_shortcut_->GetPreferredSize();
+    width += size.width() + kButtonPadding;
+  }
 
   return gfx::Size(width, height);
 }
 
 void BookmarkBarView::Layout() {
   LayoutItems();
 }
 
 void BookmarkBarView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
@@ skipping 174 matching lines @@
     parent_node = root;
     index = parent_node->child_count();
   } else if (drop_info_->location.on) {
     parent_node = root->GetChild(index);
     index = parent_node->child_count();
   } else {
     parent_node = root;
   }
   const BookmarkNodeData data = drop_info_->data;
   DCHECK(data.is_valid());
+  bool copy = drop_info_->location.operation == ui::DragDropTypes::DRAG_COPY;
   drop_info_.reset();
-  return chrome::DropBookmarks(browser_->profile(), data, parent_node, index);
+  return chrome::DropBookmarks(
+      browser_->profile(), data, parent_node, index, copy);
 }
 
 void BookmarkBarView::OnThemeChanged() {
   UpdateColors();
 }
 
 const char* BookmarkBarView::GetClassName() const {
   return kViewClassName;
 }
 
@@ skipping 34 matching lines @@
   } else if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     UMA_HISTOGRAM_COUNTS("Import.ShowDialog.FromFloatingBookmarkBarView",
                          time_from_install);
   }
 
   chrome::ShowImportDialog(browser_);
 }
 
 void BookmarkBarView::OnBookmarkBubbleShown(const GURL& url) {
   StopThrobbing(true);
-  const BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(url);
+  const BookmarkNode* node = model_->GetMostRecentlyAddedUserNodeForURL(url);
   if (!node)
     return;  // Generally shouldn't happen.
   StartThrobbing(node, false);
 }
 
 void BookmarkBarView::OnBookmarkBubbleHidden() {
   StopThrobbing(false);
 }
 
 void BookmarkBarView::BookmarkModelLoaded(BookmarkModel* model,
                                           bool ids_reassigned) {
   // 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.
   DCHECK_EQ(0, GetBookmarkButtonCount());
   const BookmarkNode* node = model_->bookmark_bar_node();
   DCHECK(node);
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0, child_count = node->child_count(); i < child_count; ++i)
     AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
   DCHECK(model_->other_node());
   other_bookmarked_button_->SetAccessibleName(model_->other_node()->GetTitle());
   other_bookmarked_button_->SetText(model_->other_node()->GetTitle());
+  managed_bookmarks_button_->SetAccessibleName(
+      client_->managed_node()->GetTitle());
+  managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
   UpdateColors();
-  UpdateOtherBookmarksVisibility();
+  UpdateButtonsVisibility();
   other_bookmarked_button_->SetEnabled(true);
+  managed_bookmarks_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
   model_ = NULL;
+  client_ = NULL;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   bool was_throbbing = throbbing_view_ &&
       throbbing_view_ == DetermineViewToThrobFromRemove(old_parent, old_index);
   if (was_throbbing)
@@ skipping 17 matching lines @@
                                           const std::set<GURL>& removed_urls) {
   // Close the menu if the menu is showing for the deleted node.
   if (bookmark_menu_ && bookmark_menu_->node() == node)
     bookmark_menu_->Cancel();
   BookmarkNodeRemovedImpl(model, parent, old_index);
 }
 
 void BookmarkBarView::BookmarkAllNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
-  UpdateOtherBookmarksVisibility();
+  UpdateButtonsVisibility();
 
   StopThrobbing(true);
 
   // Remove the existing buttons.
   while (GetBookmarkButtonCount()) {
     delete GetBookmarkButton(0);
   }
 
   Layout();
   SchedulePaint();
@@ skipping 98 matching lines @@
   return true;
 }
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
   if (view == other_bookmarked_button_) {
     node = model_->other_node();
+  } else if (view == managed_bookmarks_button_) {
+    node = client_->managed_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 15 matching lines @@
                          content::PAGE_TRANSITION_AUTO_BOOKMARK,
                          false);
     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 {
     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 16 matching lines @@
     return;
   }
 
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarked_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 != 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 21 matching lines @@
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
   other_bookmarked_button_ = CreateOtherBookmarkedButton();
   // We'll re-enable when the model is loaded.
   other_bookmarked_button_->SetEnabled(false);
   AddChildView(other_bookmarked_button_);
 
+  managed_bookmarks_button_ = CreateOtherBookmarkedButton();
+  // Also re-enabled when the model is loaded.
+  managed_bookmarks_button_->SetEnabled(false);
+  AddChildView(managed_bookmarks_button_);
+
   apps_page_shortcut_ = CreateAppsPageShortcutButton();
   AddChildView(apps_page_shortcut_);
   profile_pref_registrar_.Init(browser_->profile()->GetPrefs());
   profile_pref_registrar_.Add(
       prefs::kShowAppsShortcutInBookmarkBar,
       base::Bind(&BookmarkBarView::OnAppsPageShortcutVisibilityPrefChanged,
                  base::Unretained(this)));
   apps_page_shortcut_->SetVisible(
       chrome::ShouldShowAppsShortcutInBookmarkBar(
           browser_->profile(), browser_->host_desktop_type()));
 
   bookmarks_separator_view_ = new ButtonSeparatorView();
   AddChildView(bookmarks_separator_view_);
   UpdateBookmarksSeparatorVisibility();
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
   size_animation_.reset(new gfx::SlideAnimation(this));
 
-  model_ = BookmarkModelFactory::GetForProfile(browser_->profile());
+  client_ = BookmarkModelFactory::GetChromeBookmarkClientForProfile(
+      browser_->profile());
+  model_ = client_->model();
   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 four non-bookmark button views: other bookmarks, bookmarks
-  // separator, chevrons (for overflow), apps page, and the instruction label.
-  return child_count() - 5;
+  // 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;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   return static_cast<views::TextButton*>(child_at(index));
 }
 
 BookmarkLaunchLocation BookmarkBarView::GetBookmarkLaunchLocation() const {
   return IsDetached() ? BOOKMARK_LAUNCH_LOCATION_DETACHED_BAR :
                         BOOKMARK_LAUNCH_LOCATION_ATTACHED_BAR;
@@ skipping 12 matching lines @@
   // Title is set in Loaded.
   MenuButton* button =
       new BookmarkFolderButton(this, base::string16(), this, false);
   button->set_id(VIEW_ID_OTHER_BOOKMARKS);
   button->SetIcon(GetFolderIcon());
   button->set_context_menu_controller(this);
   button->set_tag(kOtherFolderButtonTag);
   return button;
 }
 
+MenuButton* BookmarkBarView::CreateManagedBookmarksButton() {
+  // Title is set in Loaded.
+  MenuButton* button =
+      new BookmarkFolderButton(this, base::string16(), this, false);
+  button->set_id(VIEW_ID_MANAGED_BOOKMARKS);
+  // TODO(joaodasilva): replace with a "managed folder" icon.
+  // http://crbug.com/49598
+  button->SetIcon(GetFolderIcon());
+  button->set_context_menu_controller(this);
+  button->set_tag(kManagedFolderButtonTag);
+  return button;
+}
+
 MenuButton* BookmarkBarView::CreateOverflowButton() {
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   MenuButton* button = new OverFlowButton(this);
   button->SetIcon(*rb->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 57 matching lines @@
       button->SetIcon(*favicon.ToImageSkia());
     else
       button->SetIcon(GetDefaultFavicon());
   }
   button->set_max_width(kMaxButtonWidth);
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
-  UpdateOtherBookmarksVisibility();
+  UpdateButtonsVisibility();
   if (parent != model_->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   const BookmarkNode* node = parent->GetChild(index);
   ProfileSyncService* sync_service(ProfileSyncServiceFactory::
       GetInstance()->GetForProfile(browser_->profile()));
   if (!throbbing_view_ && sync_service && sync_service->FirstSetupInProgress())
     StartThrobbing(node, true);
   AddChildViewAt(CreateBookmarkButton(node), index);
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
-  UpdateOtherBookmarksVisibility();
+  UpdateButtonsVisibility();
 
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
   // the same time as the user reorders.
 
   if (parent != model_->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
@@ skipping 89 matching lines @@
   Profile* profile = browser_->profile();
   if (other_bookmarked_button_->visible() && other_delta_x >= 0 &&
       other_delta_x < other_bookmarked_button_->width()) {
     // Mouse is over 'other' folder.
     location->button_type = DROP_OTHER_FOLDER;
     location->on = true;
     found = true;
   } else if (!GetBookmarkButtonCount()) {
     // No bookmarks, accept the drop.
     location->index = 0;
-    int ops = data.GetFirstNode(model_, profile->GetPath()) ?
+    const BookmarkNode* node = data.GetFirstNode(model_, profile->GetPath());
+    int ops = node && client_->CanBeEditedByUser(node) ?
         ui::DragDropTypes::DRAG_MOVE :
         ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
     location->operation = chrome::GetPreferredBookmarkDropOperation(
         event.source_operations(), ops);
     return;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
        GetBookmarkButton(i)->visible() && !found; i++) {
     views::TextButton* button = GetBookmarkButton(i);
@@ skipping 85 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)) {
+    throbbing_view_ = managed_bookmarks_button_;
   } else if (!overflow_only) {
     throbbing_view_ = other_bookmarked_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))
+    return managed_bookmarks_button_;
   // Node wasn't on the bookmark bar, use the other bookmark button.
   return other_bookmarked_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 text_color =
       theme_provider->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetEnabledColor(text_color);
-  other_bookmarked_button()->SetEnabledColor(text_color);
+  other_bookmarked_button_->SetEnabledColor(text_color);
+  managed_bookmarks_button_->SetEnabledColor(text_color);
   if (apps_page_shortcut_->visible())
     apps_page_shortcut_->SetEnabledColor(text_color);
 }
 
-void BookmarkBarView::UpdateOtherBookmarksVisibility() {
+void BookmarkBarView::UpdateButtonsVisibility() {
   bool has_other_children = !model_->other_node()->empty();
-  if (has_other_children == other_bookmarked_button_->visible())
-    return;
-  other_bookmarked_button_->SetVisible(has_other_children);
-  UpdateBookmarksSeparatorVisibility();
-  Layout();
-  SchedulePaint();
+  bool update_other = has_other_children != other_bookmarked_button_->visible();
+  if (update_other) {
+    other_bookmarked_button_->SetVisible(has_other_children);
+    UpdateBookmarksSeparatorVisibility();
+  }
+
+  bool has_managed_children = !client_->managed_node()->empty();
+  bool update_managed =
+      has_managed_children != managed_bookmarks_button_->visible();
+  if (update_managed)
+    managed_bookmarks_button_->SetVisible(has_managed_children);
+
+  if (update_other || update_managed) {
+    Layout();
+    SchedulePaint();
+  }
 }
 
 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_bookmarked_button_->visible());
 }
 
@@ skipping 21 matching lines @@
     y += View::height() - chrome::kBookmarkBarHeight;
   }
 
   gfx::Size other_bookmarked_pref = other_bookmarked_button_->visible() ?
       other_bookmarked_button_->GetPreferredSize() : gfx::Size();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
   gfx::Size apps_page_shortcut_pref = apps_page_shortcut_->visible() ?
       apps_page_shortcut_->GetPreferredSize() : gfx::Size();
+  gfx::Size managed_bookmarks_pref = managed_bookmarks_button_->visible() ?

[sky, 2014/06/05 23:46:47]

Move to 1848.

[Joao da Silva, 2014/06/06 15:41:03]

Done.

+      managed_bookmarks_button_->GetPreferredSize() : gfx::Size();
 
   int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width();
   if (other_bookmarked_button_->visible())
     max_x -= other_bookmarked_pref.width() + kButtonPadding;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
-  // visible region and made invisible.
+  // visible region are made invisible.
 
   // 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()) {
+    managed_bookmarks_button_->SetBounds(x, y, managed_bookmarks_pref.width(),
+                                         height);
+    x += managed_bookmarks_pref.width() + kButtonPadding;
+  }
+
   // Then go through the bookmark buttons.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->loaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     instructions_->SetBounds(
         x + kInstructionsPadding, y,
         std::min(static_cast<int>(pref.width()),
                  max_x - x),
         height);
     instructions_->SetVisible(true);
   } else {
@@ skipping 44 matching lines @@
   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();
   Layout();
 }