Makes the chevron throb after a user sync'ed his bookmarks (if the overflow m...

chrome/browser/views/bookmark_bar_view.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/views/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 230 matching lines @@
   virtual void Paint(gfx::Canvas *canvas) {
     views::MenuButton::Paint(canvas, false);
   }
 
  private:
   scoped_ptr<SlideAnimation> show_animation_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkFolderButton);
 };
 
+// OverFlowButton (chevron) --------------------------------------------------
+
+class OverFlowButton : public views::MenuButton {
+ public:
+  explicit OverFlowButton(BookmarkBarView* owner)
+      : MenuButton(NULL, std::wstring(), owner, false),
+        owner_(owner) {}
+
+  virtual bool OnMousePressed(const views::MouseEvent& e) {
+    owner_->StopThrobbing(true);
+    return views::MenuButton::OnMousePressed(e);
+  }
+
+ private:
+  BookmarkBarView* owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverFlowButton);
+};
+
 }  // namespace
 
 // DropInfo -------------------------------------------------------------------
 
 // Tracks drops on the BookmarkBarView.
 
 struct BookmarkBarView::DropInfo {
   DropInfo()
       : valid(false),
         drop_index(-1),
@@ skipping 641 matching lines @@
       false);
   button->SetIcon(GetGroupIcon());
   button->SetContextMenuController(this);
   button->set_tag(kOtherFolderButtonTag);
   button->SetAccessibleName(
       l10n_util::GetString(IDS_BOOMARK_BAR_OTHER_BOOKMARKED));
   return button;
 }
 
 MenuButton* BookmarkBarView::CreateOverflowButton() {
-  MenuButton* button = new MenuButton(NULL, std::wstring(), this, false);
+  MenuButton* button = new OverFlowButton(this);
   button->SetIcon(*ResourceBundle::GetSharedInstance().
                   GetBitmapNamed(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
   // text and flipping the gfx::Canvas object will break text rendering. Since
   // the overflow button does not contain text, we can safely flip it.
@@ skipping 36 matching lines @@
   NotifyModelChanged();
   model_->RemoveObserver(this);
   model_ = NULL;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
-  StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, old_parent, old_index);
   BookmarkNodeAddedImpl(model, new_parent, new_index);
-  StartThrobbing();
 }
 
 void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
                                         const BookmarkNode* parent,
                                         int index) {
-  StopThrobbing(true);
   BookmarkNodeAddedImpl(model, parent, index);
-  StartThrobbing();
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
-  AddChildView(index, CreateBookmarkButton(parent->GetChild(index)));
+  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) {
-  StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, parent, old_index);
-  StartThrobbing();
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
   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();
@@ skipping 259 matching lines @@
   DCHECK(profile_);
   switch (type.value) {
     case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
       if (IsAlwaysShown()) {
         size_animation_->Show();
       } else {
         size_animation_->Hide();
       }
       break;
 
-    case NotificationType::BOOKMARK_BUBBLE_SHOWN:
+    case NotificationType::BOOKMARK_BUBBLE_SHOWN: {
       StopThrobbing(true);
-      bubble_url_ = *(Details<GURL>(details).ptr());
-      StartThrobbing();
+      GURL url = *(Details<GURL>(details).ptr());
+      const BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(url);
+      if (!node)
+        return;  // Generally shouldn't happen.
+      StartThrobbing(node, false);
       break;
-
+    }
     case NotificationType::BOOKMARK_BUBBLE_HIDDEN:
       StopThrobbing(false);
-      bubble_url_ = GURL();
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void BookmarkBarView::ThemeChanged() {
   UpdateColors();
@@ skipping 174 matching lines @@
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
     if (!GetBookmarkButton(i)->IsVisible())
       return i;
   }
   return bb_count;
 }
 
-void BookmarkBarView::StartThrobbing() {
+void BookmarkBarView::StartThrobbing(const BookmarkNode* node,
+                                     bool overflow_only) {
   DCHECK(!throbbing_view_);
 
-  if (bubble_url_.is_empty())
-    return;  // Bubble isn't showing; nothing to throb.
-
-  if (!GetWidget())
-    return;  // We're not showing, don't do anything.
-
-  const BookmarkNode* node =
-      model_->GetMostRecentlyAddedNodeForURL(bubble_url_);
-  if (!node)
-    return;  // Generally shouldn't happen.
-
-  // Determine which visible button is showing the url (or is an ancestor of
-  // the url).
-  if (node->HasAncestor(model_->GetBookmarkBarNode())) {
-    const BookmarkNode* bbn = model_->GetBookmarkBarNode();
-    const BookmarkNode* parent_on_bb = node;
-    while (parent_on_bb->GetParent() != bbn)
-      parent_on_bb = parent_on_bb->GetParent();
+  // Determine which visible button is showing the bookmark (or is an ancestor
+  // of the bookmark).
+  const BookmarkNode* bbn = model_->GetBookmarkBarNode();
+  const BookmarkNode* parent_on_bb = node;
+  while (parent_on_bb) {
+    const BookmarkNode* parent = parent_on_bb->GetParent();
+    if (parent == bbn)
+      break;
+    parent_on_bb = parent;
+  }
+  if (parent_on_bb) {
     int index = bbn->IndexOfChild(parent_on_bb);
     if (index >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       throbbing_view_ = overflow_button_;
-    } else {
+    } else if (!overflow_only) {
       throbbing_view_ = static_cast<CustomButton*>(GetChildViewAt(index));
     }
-  } else {
+  } else if (!overflow_only) {
     throbbing_view_ = other_bookmarked_button_;
   }
 
   // Use a large number so that the button continues to throb.
-  throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
+  if (throbbing_view_)
+    throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 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 175 matching lines @@
   // The tooltip is the only way we have to display text explaining the error
   // to the user.
   sync_error_button->SetTooltipText(
       l10n_util::GetString(IDS_SYNC_BOOKMARK_BAR_ERROR_DESC));
   sync_error_button->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_SYNC_ERROR_BUTTON));
   sync_error_button->SetIcon(
       *ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING));
   return sync_error_button;
 }