Makes the other bookmark button on the bookmark bar visible only if it

chrome/browser/ui/views/bookmark_bar_view.cc

 // Copyright (c) 2011 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/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 956 matching lines @@
   volatile int button_count = GetBookmarkButtonCount();
   DCHECK(button_count == 0);  // If non-zero it means Load was invoked more than
                               // once, or we didn't properly clear things.
                               // Either of which shouldn't happen
   const BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0, child_count = node->GetChildCount(); i < child_count; ++i)
     AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
   UpdateColors();
+  other_bookmarked_button_->SetVisible(
+      model->other_node()->GetChildCount() > 0);
   other_bookmarked_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // In normal shutdown The bookmark model should never be deleted before us.
   // When X exits suddenly though, it can happen, This code exists
   // to check for regressions in shutdown code and not crash.
@@ skipping 17 matching lines @@
 
 void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
                                         const BookmarkNode* parent,
                                         int index) {
   BookmarkNodeAddedImpl(model, parent, index);
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
+  other_bookmarked_button_->SetVisible(
+      model->other_node()->GetChildCount() > 0);
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   const BookmarkNode* node = parent->GetChild(index);
   if (!throbbing_view_ && sync_service_ && sync_service_->SetupInProgress()) {
     StartThrobbing(node, true);
   }
   AddChildView(index, CreateBookmarkButton(node));
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
                                           const BookmarkNode* parent,
                                           int old_index,
                                           const BookmarkNode* node) {
   BookmarkNodeRemovedImpl(model, parent, old_index);
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
+  other_bookmarked_button_->SetVisible(
+      model->other_node()->GetChildCount() > 0);
+
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
   // the same time as the user reorders.
 
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
@@ skipping 503 matching lines @@
   } 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());
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
-  // We contain at least four non-bookmark button views: other bookmarks,
-  // bookmarks separator, chevrons (for overflow), the instruction label and
-  // the sync error button.
+  // We contain five non-bookmark button views: other bookmarks, bookmarks
+  // separator, chevrons (for overflow), the instruction label and the sync
+  // error button.
   return GetChildViewCount() - 5;
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
   throbbing_view_ = NULL;
@@ skipping 31 matching lines @@
         (kNewtabVerticalPadding) * current_state);
     width -= static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding) * current_state);
     height -= static_cast<int>(static_cast<double>
         (kNewtabVerticalPadding * 2) * current_state);
     separator_margin -= static_cast<int>(static_cast<double>
         (kSeparatorMargin) * current_state);
   }
 
   gfx::Size other_bookmarked_pref =
-      other_bookmarked_button_->GetPreferredSize();
+      other_bookmarked_button_->IsVisible() ?
+      other_bookmarked_button_->GetPreferredSize() : gfx::Size();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
 
   int sync_error_total_width = 0;
   gfx::Size sync_error_button_pref = sync_error_button_->GetPreferredSize();
   if (sync_ui_util::ShouldShowSyncErrorButton(sync_service_)) {
     sync_error_total_width += kButtonPadding + sync_error_button_pref.width();
   }
-  const int max_x = width - other_bookmarked_pref.width() - kButtonPadding -
-      overflow_pref.width() - kButtonPadding -
+  int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width() - sync_error_total_width;
+  if (other_bookmarked_button_->IsVisible())
+    max_x -= other_bookmarked_pref.width() + kButtonPadding;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->IsLoaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     if (!compute_bounds_only) {
       instructions_->SetBounds(
           x + kInstructionsPadding, y,
           std::min(static_cast<int>(pref.width()),
           max_x - x),
@@ skipping 39 matching lines @@
     bookmarks_separator_view_->SetBounds(x,
                                          y - top_margin,
                                          bookmarks_separator_pref.width(),
                                          height + top_margin + kBottomMargin -
                                          separator_margin);
   }
 
   x += bookmarks_separator_pref.width();
 
   // The other bookmarks button.
-  if (!compute_bounds_only) {
-    other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
-                                        height);
+  if (other_bookmarked_button_->IsVisible()) {
+    if (!compute_bounds_only) {
+      other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
+                                          height);
+    }
+    x += other_bookmarked_pref.width() + kButtonPadding;
   }
-  x += other_bookmarked_pref.width() + kButtonPadding;
 
   // Set the real bounds of the sync error button only if it needs to appear on
   // the bookmarks bar.
   if (sync_ui_util::ShouldShowSyncErrorButton(sync_service_)) {
     x += kButtonPadding;
     if (!compute_bounds_only) {
       sync_error_button_->SetBounds(
           x, y, sync_error_button_pref.width(), height);
       sync_error_button_->SetVisible(true);
     }
@@ skipping 30 matching lines @@
   // The tooltip is the only way we have to display text explaining the error
   // to the user.
   sync_error_button->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_SYNC_BOOKMARK_BAR_ERROR_DESC)));
   sync_error_button->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_SYNC_ERROR_BUTTON));
   sync_error_button->SetIcon(
       *ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING));
   return sync_error_button;
 }