A little bit of bookmark bar cleanup, a little bit of padding improvement....

chrome/browser/gtk/bookmark_bar_gtk.cc

 // Copyright (c) 2009 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/gtk/bookmark_bar_gtk.h"
 
 #include <vector>
 
 #include "app/gfx/text_elider.h"
 #include "app/l10n_util.h"
@@ skipping 67 matching lines @@
   if (profile_ == profile)
     return;
 
   RemoveAllBookmarkButtons();
 
   profile_ = profile;
 
   if (model_)
     model_->RemoveObserver(this);
 
-  gtk_widget_set_sensitive(other_bookmarks_button_, false);
-
   // TODO(erg): Handle extensions
 
   model_ = profile_->GetBookmarkModel();
   model_->AddObserver(this);
   if (model_->IsLoaded())
     Loaded(model_);
 
   // else case: we'll receive notification back from the BookmarkModel when done
   // loading, then we'll populate the bar.
 }
 
 void BookmarkBarGtk::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
 }
 
 void BookmarkBarGtk::Init(Profile* profile) {
-  // Load the default images from the resource bundle.
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  static GdkPixbuf* folder_icon = rb.GetPixbufNamed(IDR_BOOKMARK_BAR_FOLDER);
-
   bookmark_hbox_.Own(gtk_hbox_new(FALSE, 0));
 
   instructions_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
   gtk_alignment_set_padding(GTK_ALIGNMENT(instructions_), 0, 0,
                             kInstructionsPadding, 0);
   g_signal_connect(instructions_, "destroy", G_CALLBACK(gtk_widget_destroyed),
                    &instructions_);
   GtkWidget* instructions_label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_BOOKMARKS_NO_ITEMS).c_str());
   gtk_widget_modify_fg(instructions_label, GTK_STATE_NORMAL,
@@ skipping 28 matching lines @@
   g_signal_connect(bookmark_toolbar_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressed), this);
 
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), gtk_vseparator_new(),
                      FALSE, FALSE, 0);
 
   // We pack the button manually (rather than using gtk_button_set_*) so that
   // we can have finer control over its label.
   other_bookmarks_button_ = gtk_chrome_button_new();
   ConnectFolderButtonEvents(other_bookmarks_button_);
-  gtk_chrome_button_set_use_gtk_rendering(
-      GTK_CHROME_BUTTON(other_bookmarks_button_),
-      GtkThemeProvider::UseSystemThemeGraphics(profile));
-
-  GtkWidget* image = gtk_image_new_from_pixbuf(folder_icon);
-  other_bookmarks_label_ = gtk_label_new(
-      l10n_util::GetStringUTF8(IDS_BOOMARK_BAR_OTHER_BOOKMARKED).c_str());
-  GtkThemeProperties properties(profile);
-  bookmark_utils::SetButtonTextColors(other_bookmarks_label_, &properties);
-
-  GtkWidget* box = gtk_hbox_new(FALSE, bookmark_utils::kBarButtonPadding);
-  gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0);
-  gtk_box_pack_start(GTK_BOX(box), other_bookmarks_label_, FALSE, FALSE, 0);
-  gtk_container_add(GTK_CONTAINER(other_bookmarks_button_), box);
-
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), other_bookmarks_button_,
                      FALSE, FALSE, 0);
 
   // Set the current theme state for all the buttons.
   gtk_widget_set_size_request(bookmark_hbox_.get(), -1, 0);
 
   slide_animation_.reset(new SlideAnimation(this));
 }
 
 void BookmarkBarGtk::AddBookmarkbarToBox(GtkWidget* box) {
@@ skipping 40 matching lines @@
 bool BookmarkBarGtk::OnNewTabPage() {
   return (browser_ && browser_->GetSelectedTabContents() &&
           browser_->GetSelectedTabContents()->IsBookmarkBarAlwaysVisible());
 }
 
 void BookmarkBarGtk::Loaded(BookmarkModel* model) {
   // If |instructions_| has been nulled, we are in the middle of browser
   // shutdown. Do nothing.
   if (!instructions_)
     return;
+
   RemoveAllBookmarkButtons();
-
-  const BookmarkNode* node = model_->GetBookmarkBarNode();
-  DCHECK(node && model_->other_node());
-  CreateAllBookmarkButtons(node);
-
-  gtk_widget_set_sensitive(other_bookmarks_button_, true);
+  CreateAllBookmarkButtons();
 }
 
 void BookmarkBarGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // The bookmark model should never be deleted before us. This code exists
   // to check for regressions in shutdown code and not crash.
   NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
   model_ = NULL;
@@ skipping 14 matching lines @@
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
 
   GtkToolItem* item = CreateBookmarkToolItem(parent->GetChild(index));
   gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()),
                      item, index);
 
-  SetInstructionState(parent);
+  SetInstructionState();
 }
 
 void BookmarkBarGtk::BookmarkNodeRemoved(BookmarkModel* model,
                                          const BookmarkNode* parent,
                                          int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
 
   GtkWidget* to_remove = GTK_WIDGET(gtk_toolbar_get_nth_item(
       GTK_TOOLBAR(bookmark_toolbar_.get()), index));
   gtk_container_remove(GTK_CONTAINER(bookmark_toolbar_.get()),
                        to_remove);
 
-  SetInstructionState(parent);
+  SetInstructionState();
 }
 
 void BookmarkBarGtk::BookmarkNodeChanged(BookmarkModel* model,
                                          const BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK(index != -1);
@@ skipping 10 matching lines @@
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                    const BookmarkNode* node) {
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
 
   // Purge and rebuild the bar.
   RemoveAllBookmarkButtons();
-  CreateAllBookmarkButtons(node);
+  CreateAllBookmarkButtons();
 }
 
-void BookmarkBarGtk::CreateAllBookmarkButtons(const BookmarkNode* node) {
+void BookmarkBarGtk::CreateAllBookmarkButtons() {
+  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; i < node->GetChildCount(); ++i) {
     GtkToolItem* item = CreateBookmarkToolItem(node->GetChild(i));
     gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
   }
 
-  SetInstructionState(node);
+  GtkThemeProperties properties(profile_);
+  bookmark_utils::ConfigureButtonForNode(model_->other_node(),
+      model_, other_bookmarks_button_, &properties);
+
+  SetInstructionState();
 }
 
-void BookmarkBarGtk::SetInstructionState(
-    const BookmarkNode* boomarks_bar_node) {
-  show_instructions_ = (boomarks_bar_node->GetChildCount() == 0);
+void BookmarkBarGtk::SetInstructionState() {
+  show_instructions_ = (model_->GetBookmarkBarNode()->GetChildCount() == 0);
   if (show_instructions_) {
     gtk_widget_show_all(instructions_);
   } else {
     gtk_widget_hide(instructions_);
   }
 }
 
 void BookmarkBarGtk::RemoveAllBookmarkButtons() {
   gtk_util::RemoveAllChildren(bookmark_toolbar_.get());
 }
 
 int BookmarkBarGtk::GetBookmarkButtonCount() {
   GList* children = gtk_container_get_children(
       GTK_CONTAINER(bookmark_toolbar_.get()));
   int count = g_list_length(children);
   g_list_free(children);
   return count;
 }
 
 bool BookmarkBarGtk::IsAlwaysShown() {
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
 void BookmarkBarGtk::UserChangedTheme(GtkThemeProperties* properties) {
-  gtk_chrome_button_set_use_gtk_rendering(
-      GTK_CHROME_BUTTON(other_bookmarks_button_),
-      properties->use_gtk_rendering);
-  bookmark_utils::SetButtonTextColors(other_bookmarks_label_, properties);
-
   if (model_) {
     // Regenerate the bookmark bar with all new objects with their theme
     // properties set correctly for the new theme.
     RemoveAllBookmarkButtons();
-
-    const BookmarkNode* node = model_->GetBookmarkBarNode();
-    DCHECK(node && model_->other_node());
-    CreateAllBookmarkButtons(node);
+    CreateAllBookmarkButtons();
   } else {
     DLOG(ERROR) << "Received a theme change notification while we don't have a "
                 << "BookmarkModel. Taking no action.";
   }
 }
 
 void BookmarkBarGtk::AnimationProgressed(const Animation* animation) {
   DCHECK_EQ(animation, slide_animation_.get());
 
   gtk_widget_set_size_request(bookmark_hbox_.get(), -1,
@@ skipping 424 matching lines @@
   bar->InitBackground();
   gfx::Point tabstrip_origin =
       bar->window_->tabstrip()->GetTabStripOriginForWidget(widget);
   bar->background_ninebox_->RenderTopCenterStrip(
       cr, tabstrip_origin.x(), tabstrip_origin.y(),
       event->area.x + event->area.width - tabstrip_origin.x());
   cairo_destroy(cr);
 
   return FALSE;  // Propagate expose to children.
 }