Fix and simplify bookmark bar detach/attach animation.

chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc

 // Copyright (c) 2012 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 <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 529 matching lines @@
       other_bookmarks_button_(NULL),
       managed_bookmarks_button_(NULL),
       supervised_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
+      size_animation_(this),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false),
       show_folder_method_factory_(this) {
   set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
 
-  size_animation_->Reset(1);
+  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);
@@ skipping 28 matching lines @@
 }
 
 void BookmarkBarView::SetBookmarkBarState(
     BookmarkBar::State state,
     BookmarkBar::AnimateChangeType animate_type) {
   if (animate_type == BookmarkBar::ANIMATE_STATE_CHANGE &&
       animations_enabled) {
     animating_detached_ = (state == BookmarkBar::DETACHED ||
                            bookmark_bar_state_ == BookmarkBar::DETACHED);
     if (state == BookmarkBar::SHOW)
-      size_animation_->Show();
+      size_animation_.Show();
     else
-      size_animation_->Hide();
+      size_animation_.Hide();
   } else {
-    size_animation_->Reset(state == BookmarkBar::SHOW ? 1 : 0);
+    size_animation_.Reset(state == BookmarkBar::SHOW ? 1 : 0);
   }
   bookmark_bar_state_ = state;
 }
 
-bool BookmarkBarView::is_animating() {
-  return size_animation_->is_animating();
-}
-
 const BookmarkNode* BookmarkBarView::GetNodeForButtonAtModelIndex(
     const gfx::Point& loc,
     int* model_start_index) {
   *model_start_index = 0;
 
   if (loc.x() < 0 || loc.x() >= width() || loc.y() < 0 || loc.y() >= height())
     return NULL;
 
   gfx::Point adjusted_loc(GetMirroredXInView(loc.x()), loc.y());
 
@@ skipping 117 matching lines @@
     base::string16 elided_url(
         url_formatter::ElideUrl(url, tt_fonts, max_width, languages));
     elided_url = base::i18n::GetDisplayStringInLTRDirectionality(elided_url);
     result.append(elided_url);
   }
   return result;
 }
 
 bool BookmarkBarView::IsDetached() const {
   return (bookmark_bar_state_ == BookmarkBar::DETACHED) ||
-      (animating_detached_ && size_animation_->is_animating());
-}
-
-double BookmarkBarView::GetAnimationValue() const {
-  return size_animation_->GetCurrentValue();
+      (animating_detached_ && size_animation_.is_animating());
 }
 
 int BookmarkBarView::GetToolbarOverlap() const {
   int attached_overlap = kToolbarAttachedBookmarkBarOverlap +
       views::NonClientFrameView::kClientEdgeThickness;
   if (!IsDetached())
     return attached_overlap;
 
   int detached_overlap = views::NonClientFrameView::kClientEdgeThickness;
 
   // Do not animate the overlap when the infobar is above us (i.e. when we're
   // detached), since drawing over the infobar looks weird.
   if (infobar_visible_)
     return detached_overlap;
 
   // When detached with no infobar, animate the overlap between the attached and
   // detached states.
   return detached_overlap + static_cast<int>(
       (attached_overlap - detached_overlap) *
-          size_animation_->GetCurrentValue());
+          size_animation_.GetCurrentValue());
 }
 
 gfx::Size BookmarkBarView::GetPreferredSize() const {
   gfx::Size prefsize;
   if (IsDetached()) {
     prefsize.set_height(
         chrome::kBookmarkBarHeight +
         static_cast<int>(
             (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
-            (1 - size_animation_->GetCurrentValue())));
+            (1 - size_animation_.GetCurrentValue())));
   } else {
     prefsize.set_height(static_cast<int>(chrome::kBookmarkBarHeight *
-                                         size_animation_->GetCurrentValue()));
+                                         size_animation_.GetCurrentValue()));
   }
   return prefsize;
 }
 
 bool BookmarkBarView::CanProcessEventsWithinSubtree() const {
   // If the bookmark bar is attached and the omnibox popup is open (on top of
   // the bar), prevent events from targeting the bookmark bar or any of its
   // descendants. This will prevent hovers/clicks just above the omnibox popup
   // from activating the top few pixels of items on the bookmark bar.
   if (!IsDetached() && browser_view_ &&
       browser_view_->GetLocationBar()->GetOmniboxView()->model()->
           popup_model()->IsOpen()) {
     return false;
   }
   return true;
 }
 
 gfx::Size BookmarkBarView::GetMinimumSize() const {
   // 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.
   // It should also contain the Managed and/or Supervised Bookmarks folders,
   // if they are visible.
   int width = GetHorizontalMargin();
 
   int height = chrome::kBookmarkBarHeight;
   if (IsDetached()) {
-    double current_state = 1 - size_animation_->GetCurrentValue();
+    double current_state = 1 - size_animation_.GetCurrentValue();
     width += 2 * static_cast<int>(kNewTabHorizontalPadding * current_state);
     height += static_cast<int>(
         (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
             current_state);
   }
 
   if (managed_bookmarks_button_->visible()) {
     gfx::Size size = managed_bookmarks_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
@@ skipping 27 matching lines @@
     return;
 
   int x = GetHorizontalMargin();
   int top_margin = IsDetached() ? kDetachedTopMargin : 0;
   int y = top_margin;
   int width = View::width() - 2 * GetHorizontalMargin();
   int height = chrome::kBookmarkBarHeight - kBottomMargin;
   int separator_margin = kSeparatorMargin;
 
   if (IsDetached()) {
-    double current_state = 1 - size_animation_->GetCurrentValue();
+    double current_state = 1 - size_animation_.GetCurrentValue();
     x += static_cast<int>(kNewTabHorizontalPadding * current_state);
     y += (View::height() - chrome::kBookmarkBarHeight) / 2;
     width -= static_cast<int>(kNewTabHorizontalPadding * current_state);
     separator_margin -= static_cast<int>(kSeparatorMargin * current_state);
   } else {
     // For the attached appearance, pin the content to the bottom of the bar
     // when animating in/out, as shrinking its height instead looks weird.  This
     // also matches how we layout infobars.
     y += View::height() - chrome::kBookmarkBarHeight;
   }
@@ skipping 499 matching lines @@
                                       &press_pt, data, widget);
       WriteBookmarkDragData(node, data);
       return;
     }
   }
   NOTREACHED();
 }
 
 int BookmarkBarView::GetDragOperationsForView(View* sender,
                                               const gfx::Point& p) {
-  if (size_animation_->is_animating() ||
-      (size_animation_->GetCurrentValue() == 0 &&
+  if (size_animation_.is_animating() ||
+      (size_animation_.GetCurrentValue() == 0 &&
        bookmark_bar_state_ != BookmarkBar::DETACHED)) {
     // Don't let the user drag while animating open or we're closed (and not
     // detached, when detached size_animation_ is always 0). This typically is
     // only hit if the user does something to inadvertently trigger DnD such as
     // pressing the mouse and hitting control-b.
     return ui::DragDropTypes::DRAG_NONE;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
@@ skipping 191 matching lines @@
 
   bookmarks_separator_view_ = new ButtonSeparatorView();
   AddChildView(bookmarks_separator_view_);
   UpdateBookmarksSeparatorVisibility();
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
-  size_animation_.reset(new gfx::SlideAnimation(this));
-
   model_ = BookmarkModelFactory::GetForProfile(browser_->profile());
   managed_ = ManagedBookmarkServiceFactory::GetForProfile(browser_->profile());
   if (model_) {
     model_->AddObserver(this);
     if (model_->loaded())
       BookmarkModelLoaded(model_, false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
@@ skipping 490 matching lines @@
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   LayoutAndPaint();
 }
 
 void BookmarkBarView::OnShowManagedBookmarksPrefChanged() {
   if (UpdateOtherAndManagedButtonsVisibility())
     LayoutAndPaint();
 }