Remove sync error button from bookmark bar

chrome/browser/ui/views/bookmarks/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/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/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_service.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/sync/profile_sync_service.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_context_menu.h"
 #include "chrome/browser/ui/views/event_utils.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 76 matching lines @@
 
 // Starting x-coordinate of the separator line within a separator.
 static const int kSeparatorStartX = 2;
 
 // 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 sync error button.
-static const int kSyncErrorButtonTag = 2;
-
 namespace {
 
 // BookmarkButton -------------------------------------------------------------
 
 // Buttons used for the bookmarks on the bookmark bar.
 
 class BookmarkButton : public views::TextButton {
  public:
   // The internal view class name.
   static const char kViewClassName[];
@@ skipping 230 matching lines @@
   return *kFolderIcon;
 }
 
 BookmarkBarView::BookmarkBarView(Browser* browser)
     : page_navigator_(NULL),
       model_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(show_folder_method_factory_(this)),
-      sync_error_button_(NULL),
-      sync_service_(browser->profile()->GetProfileSyncService()),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false) {
-  if (sync_service_)
-    sync_service_->AddObserver(this);
-
   set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
 
   size_animation_->Reset(1);
 }
 
 BookmarkBarView::~BookmarkBarView() {
   if (model_)
     model_->RemoveObserver(this);
 
   // It's possible for the menu to outlive us, reset the observer to make sure
   // it doesn't have a reference to us.
   if (bookmark_menu_) {
     bookmark_menu_->set_observer(NULL);
     bookmark_menu_->SetPageNavigator(NULL);
   }
   if (context_menu_.get())
     context_menu_->SetPageNavigator(NULL);
 
   StopShowFolderDropMenuTimer();
-
-  if (sync_service_)
-    sync_service_->RemoveObserver(this);
 }
 
 void BookmarkBarView::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
   if (bookmark_menu_)
     bookmark_menu_->SetPageNavigator(navigator);
   if (context_menu_.get())
     context_menu_->SetPageNavigator(navigator);
 }
 
@@ skipping 167 matching lines @@
   // 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.
   int width = kLeftMargin;
 
   if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(kNewtabHorizontalPadding * current_state);
   }
 
-  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();
-
   gfx::Size other_bookmarked_pref =
       other_bookmarked_button_->GetPreferredSize();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
 
   width += (other_bookmarked_pref.width() + kButtonPadding +

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

Nit: No parens needed

[sail, 2011/10/27 00:45:54]

Done.

       overflow_pref.width() + kButtonPadding +
-      bookmarks_separator_pref.width() + sync_error_total_width);
+      bookmarks_separator_pref.width());
 
   return gfx::Size(width, browser_defaults::kBookmarkBarHeight);
 }
 
 void BookmarkBarView::Layout() {
   LayoutItems(false);
 }
 
 void BookmarkBarView::ViewHierarchyChanged(bool is_add,
                                            View* parent,
@@ skipping 199 matching lines @@
 
 std::string BookmarkBarView::GetClassName() const {
   return kViewClassName;
 }
 
 void BookmarkBarView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TOOLBAR;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS);
 }
 
-void BookmarkBarView::OnStateChanged() {
-  // When the sync state changes, it is sufficient to invoke View::Layout since
-  // during layout we query the profile sync service and determine whether the
-  // new state requires showing the sync error button so that the user can
-  // re-enter her password. If extension shelf appears along with the bookmark
-  // shelf, it too needs to be layed out. Since both have the same parent, it is
-  // enough to let the parent layout both of these children.
-  // TODO(sky): This should not require Layout() and SchedulePaint(). Needs
-  //            some cleanup.
-  PreferredSizeChanged();
-  Layout();
-  SchedulePaint();
-}
-
 void BookmarkBarView::AnimationProgressed(const ui::Animation* animation) {
   if (browser_)
     browser_->BookmarkBarSizeChanged(true);
 }
 
 void BookmarkBarView::AnimationEnded(const ui::Animation* animation) {
   if (browser_)
     browser_->BookmarkBarSizeChanged(false);
 
   SchedulePaint();
@@ skipping 180 matching lines @@
   }
 
   bookmark_menu_ = new BookmarkMenuController(browser_->profile(),
       page_navigator_, GetWidget(), node, start_index);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const views::Event& event) {
-  // Show the login wizard if the user clicked the re-login button.
-  if (sender->tag() == kSyncErrorButtonTag) {
-    DCHECK(sender == sync_error_button_);
-    DCHECK(sync_service_ && !sync_service_->IsManaged());
-    sync_service_->ShowErrorUI();
-    return;
-  }
-
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
@@ skipping 84 matching lines @@
   // UpdateColors(), which will set the appropriate colors for all the objects
   // added in this function.
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   if (!kDefaultFavicon)
     kDefaultFavicon = rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
 
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
-  sync_error_button_ = CreateSyncErrorButton();
-  AddChildView(sync_error_button_);
-
   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_);
 
   bookmarks_separator_view_ = new ButtonSeparatorView();
   AddChildView(bookmarks_separator_view_);
@@ skipping 14 matching lines @@
   if (model_) {
     model_->AddObserver(this);
     if (model_->IsLoaded())
       Loaded(model_, false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
-  // We contain five non-bookmark button views: other bookmarks, bookmarks
-  // separator, chevrons (for overflow), the instruction label and the sync
-  // error button.
-  return child_count() - 5;
+  // We contain four non-bookmark button views: other bookmarks, bookmarks
+  // separator, chevrons (for overflow), and the instruction label.
+  return child_count() - 4;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   return static_cast<views::TextButton*>(child_at(index));
 }
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
@@ skipping 33 matching lines @@
   button->EnableCanvasFlippingForRTLUI(true);
 
   // Make visible as necessary.
   button->SetVisible(false);
   // Set accessibility name.
   button->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS_CHEVRON));
   return button;
 }
 
-views::TextButton* BookmarkBarView::CreateSyncErrorButton() {
-  views::TextButton* sync_error_button = new views::TextButton(
-      this, l10n_util::GetStringUTF16(IDS_SYNC_BOOKMARK_BAR_ERROR));
-  sync_error_button->set_tag(kSyncErrorButtonTag);
-
-  // The tooltip is the only way we have to display text explaining the error
-  // to the user.
-  sync_error_button->SetTooltipText(
-      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;
-}
-
 views::View* BookmarkBarView::CreateBookmarkButton(const BookmarkNode* node) {
   if (node->is_url()) {
     BookmarkButton* button = new BookmarkButton(
         this, node->url(), node->GetTitle(), browser_->profile());
     ConfigureButton(node, button);
     return button;
   } else {
     views::MenuButton* button = new BookmarkFolderButton(
         this, node->GetTitle(), this, false);
     button->SetIcon(GetFolderIcon());
@@ skipping 28 matching lines @@
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   UpdateOtherBookmarksVisibility();
   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);
-  if (!throbbing_view_ && sync_service_ && sync_service_->SetupInProgress()) {
+  ProfileSyncService* sync_service =
+      browser_->profile()->GetProfileSyncService();
+  if (!throbbing_view_ && sync_service && sync_service->SetupInProgress())
     StartThrobbing(node, true);
-  }
   AddChildViewAt(CreateBookmarkButton(node), index);
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
   UpdateOtherBookmarksVisibility();
@@ skipping 296 matching lines @@
     height += browser_defaults::kBookmarkBarHeight;
   }
 
   gfx::Size other_bookmarked_pref =
       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();
-  }
   int max_x = width - overflow_pref.width() - kButtonPadding -
-      bookmarks_separator_pref.width() - sync_error_total_width;
+      bookmarks_separator_pref.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,
@@ skipping 51 matching lines @@
 
   // The other bookmarks button.
   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;
   }
 
-  // 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);
-    }
-    x += sync_error_button_pref.width();
-  } else if (!compute_bounds_only) {
-    sync_error_button_->SetBounds(x, y, 0, height);
-    sync_error_button_->SetVisible(false);
-  }
-
   // Set the preferred size computed so far.
   if (compute_bounds_only) {
     x += kRightMargin;
     prefsize.set_width(x);
     if (IsDetached()) {
       x += static_cast<int>(
           kNewtabHorizontalPadding * (1 - size_animation_->GetCurrentValue()));
       prefsize.set_height(
           browser_defaults::kBookmarkBarHeight +
           static_cast<int>(
               (browser_defaults::kNewtabBookmarkBarHeight -
                browser_defaults::kBookmarkBarHeight) *
               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(
           static_cast<int>(
               browser_defaults::kBookmarkBarHeight *
               size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }