Remove sync error button from bookmark bar

chrome/browser/ui/gtk/bookmarks/bookmark_bar_gtk.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/gtk/bookmarks/bookmark_bar_gtk.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/ntp_background_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_menu_controller_gtk.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_utils_gtk.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/cairo_cached_surface.h"
 #include "chrome/browser/ui/gtk/custom_button.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_button.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/hover_controller_gtk.h"
@@ skipping 93 matching lines @@
 
 BookmarkBarGtk::BookmarkBarGtk(BrowserWindowGtk* window,
                                Browser* browser,
                                TabstripOriginProvider* tabstrip_origin_provider)
     : page_navigator_(NULL),
       browser_(browser),
       window_(window),
       tabstrip_origin_provider_(tabstrip_origin_provider),
       model_(NULL),
       instructions_(NULL),
-      sync_service_(NULL),
       dragged_node_(NULL),
       drag_icon_(NULL),
       toolbar_drop_item_(NULL),
       theme_service_(GtkThemeService::GetFrom(browser->profile())),
       show_instructions_(true),
       menu_bar_helper_(this),
       slide_animation_(this),
       last_allocation_width_(-1),
       throbbing_widget_(NULL),
       weak_factory_(this),
       bookmark_bar_state_(BookmarkBar::DETACHED),
       max_height_(0) {
-  Profile* profile = browser->profile();
-  if (profile->GetProfileSyncService()) {
-    // Obtain a pointer to the profile sync service and add our instance as an
-    // observer.
-    sync_service_ = profile->GetProfileSyncService();
-    sync_service_->AddObserver(this);
-  }
-
   Init();
   // Force an update by simulating being in the wrong state.
   // BrowserWindowGtk sets our true state after we're created.
   SetBookmarkBarState(BookmarkBar::SHOW,
                       BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(theme_service_));
 
   edit_bookmarks_enabled_.Init(prefs::kEditBookmarksEnabled,
-                               profile->GetPrefs(), this);
+                               browser->profile()->GetPrefs(), this);

[Peter Kasting, 2011/10/26 18:12:01]

Nit: Personal preference, but I'd use |browser_| instead of |browser| here

   OnEditBookmarksEnabledChanged();
 }
 
 BookmarkBarGtk::~BookmarkBarGtk() {
   RemoveAllButtons();
   bookmark_toolbar_.Destroy();
   event_box_.Destroy();
 }
 
 void BookmarkBarGtk::SetPageNavigator(PageNavigator* navigator) {
@@ skipping 86 matching lines @@
   gtk_alignment_set_padding(GTK_ALIGNMENT(other_padding_),
                             kOtherBookmarksPaddingVertical,
                             kOtherBookmarksPaddingVertical,
                             kOtherBookmarksPaddingHorizontal,
                             kOtherBookmarksPaddingHorizontal);
   gtk_container_add(GTK_CONTAINER(other_padding_), other_bookmarks_button_);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), other_padding_,
                      FALSE, FALSE, 0);
   gtk_widget_set_no_show_all(other_padding_, TRUE);
 
-  sync_error_button_ = theme_service_->BuildChromeButton();
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  gtk_widget_set_tooltip_text(
-      sync_error_button_,
-      l10n_util::GetStringUTF8(IDS_SYNC_BOOKMARK_BAR_ERROR_DESC).c_str());
-  gtk_button_set_label(
-      GTK_BUTTON(sync_error_button_),
-      l10n_util::GetStringUTF8(IDS_SYNC_BOOKMARK_BAR_ERROR).c_str());
-  gtk_button_set_image(
-      GTK_BUTTON(sync_error_button_),
-      gtk_image_new_from_pixbuf(rb.GetNativeImageNamed(IDR_WARNING)));
-  g_signal_connect(sync_error_button_, "button-press-event",
-                   G_CALLBACK(OnSyncErrorButtonPressedThunk), this);
-  gtk_box_pack_start(GTK_BOX(bookmark_hbox_), sync_error_button_,
-                     FALSE, FALSE, 0);
-
   gtk_widget_set_size_request(event_box_.get(), -1, kBookmarkBarMinimumHeight);
 
   ViewIDUtil::SetID(other_bookmarks_button_, VIEW_ID_OTHER_BOOKMARKS);
   ViewIDUtil::SetID(widget(), VIEW_ID_BOOKMARK_BAR);
 
   gtk_widget_show_all(widget());
   gtk_widget_hide(widget());
 
   AddCoreButtons();
   // TODO(erg): Handle extensions
@@ skipping 164 matching lines @@
         // The event box won't stay below its children's GdkWindows unless we
         // toggle the above-child property here. If the event box doesn't stay
         // below its children then events will be routed to it rather than the
         // children.
         gtk_event_box_set_above_child(GTK_EVENT_BOX(event_box_.get()), TRUE);
         gtk_event_box_set_above_child(GTK_EVENT_BOX(event_box_.get()), FALSE);
       }
     }
   }
 
-  gtk_widget_set_visible(
-      sync_error_button_,
-      sync_ui_util::ShouldShowSyncErrorButton(sync_service_));
-
   // Maybe show the instructions
   gtk_widget_set_visible(bookmark_toolbar_.get(), !show_instructions_);
   gtk_widget_set_visible(instructions_, show_instructions_);
 
   SetChevronState();
 }
 
 void BookmarkBarGtk::Hide(BookmarkBar::State old_state,
                           BookmarkBar::AnimateChangeType animate_type) {
   UpdateDetachedState(old_state);
@@ skipping 649 matching lines @@
   if (event->button == 3 && gtk_widget_get_visible(bookmark_hbox_)) {
     const BookmarkNode* node = GetNodeForToolButton(sender);
     DCHECK(node);
     DCHECK(page_navigator_);
     PopupMenuForNode(sender, node, event);
   }
 
   return FALSE;
 }
 
-gboolean BookmarkBarGtk::OnSyncErrorButtonPressed(GtkWidget* sender,
-                                                  GdkEventButton* event) {
-  if (sender == sync_error_button_) {
-    DCHECK(sync_service_ && !sync_service_->IsManaged());
-    sync_service_->ShowErrorUI();
-  }
-
-  return FALSE;
-}
-
 void BookmarkBarGtk::OnClicked(GtkWidget* sender) {
   const BookmarkNode* node = GetNodeForToolButton(sender);
   DCHECK(node);
   DCHECK(node->is_url());
   DCHECK(page_navigator_);
 
   Profile* profile = browser_->profile();
   RecordAppLaunch(profile, node->url());
   bookmark_utils::OpenAll(window_->GetNativeHandle(), profile, page_navigator_,
       node, gtk_util::DispositionForCurrentButtonPressEvent());
@@ skipping 265 matching lines @@
     NtpBackgroundUtil::PaintBackgroundDetachedMode(theme_provider, &canvas,
         area, tab_contents_size.height());
   }
 
   return FALSE;  // Propagate expose to children.
 }
 
 void BookmarkBarGtk::OnEventBoxDestroy(GtkWidget* widget) {
   if (model_)
     model_->RemoveObserver(this);
-
-  if (sync_service_)
-    sync_service_->RemoveObserver(this);
 }
 
 void BookmarkBarGtk::OnParentSizeAllocate(GtkWidget* widget,
                                           GtkAllocation* allocation) {
   // In detached mode, our layout depends on the size of the tab contents.
   // We get the size-allocate signal before the tab contents does, hence we
   // need to post a delayed task so we will paint correctly. Note that
   // gtk_widget_queue_draw by itself does not work, despite that it claims to
   // be asynchronous.
   if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&BookmarkBarGtk::PaintEventBox, weak_factory_.GetWeakPtr()));
   }
 }
 
 void BookmarkBarGtk::OnThrobbingWidgetDestroy(GtkWidget* widget) {
   SetThrobbingWidget(NULL);
 }
 
-void BookmarkBarGtk::OnStateChanged() {
-  gtk_widget_set_visible(
-      sync_error_button_,
-      sync_ui_util::ShouldShowSyncErrorButton(sync_service_));
-}
-
 void BookmarkBarGtk::ShowImportDialog() {
   browser_->OpenImportSettingsDialog();
 }
 
 void BookmarkBarGtk::OnEditBookmarksEnabledChanged() {
   GtkDestDefaults dest_defaults =
       *edit_bookmarks_enabled_ ? GTK_DEST_DEFAULT_ALL :
                                  GTK_DEST_DEFAULT_DROP;
   gtk_drag_dest_set(overflow_button_, dest_defaults, NULL, 0, kDragAction);
   gtk_drag_dest_set(other_bookmarks_button_, dest_defaults,
                     NULL, 0, kDragAction);
   ui::SetDestTargetList(overflow_button_, kDestTargetList);
   ui::SetDestTargetList(other_bookmarks_button_, kDestTargetList);
 }