Refactoring to make adding ink drop animations easier

chrome/browser/ui/views/toolbar/toolbar_action_view.cc

 // Copyright 2013 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/toolbar/toolbar_action_view.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/theme_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/events/event.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/resources/grit/ui_resources.h"
-#include "ui/views/animation/ink_drop_animation_controller.h"
-#include "ui/views/animation/ink_drop_animation_controller_factory.h"
+#include "ui/views/animation/toolbar_ink_drop_delegate.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/mouse_constants.h"
 #include "ui/views/resources/grit/views_resources.h"
 
 using views::LabelButtonBorder;
 
 namespace {
@@ skipping 20 matching lines @@
     ToolbarActionViewController* view_controller,
     Profile* profile,
     ToolbarActionView::Delegate* delegate)
     : MenuButton(nullptr, base::string16(), this, false),
       view_controller_(view_controller),
       profile_(profile),
       delegate_(delegate),
       called_register_command_(false),
       wants_to_run_(false),
       menu_(nullptr),
-      ink_drop_animation_controller_(
-          views::InkDropAnimationControllerFactory::
-              CreateInkDropAnimationController(this)),
+      ink_drop_delegate_(new views::ToolbarInkDropDelegate(this, this)),
       weak_factory_(this) {
   set_id(VIEW_ID_BROWSER_ACTION);
   view_controller_->SetDelegate(this);
   SetHorizontalAlignment(gfx::ALIGN_CENTER);
   set_drag_controller(delegate_);
 
   set_context_menu_controller(this);
 
   const int kInkDropLargeSize = 32;
   const int kInkDropLargeCornerRadius = 5;
   const int kInkDropSmallSize = 24;
   const int kInkDropSmallCornerRadius = 2;
-
-  ink_drop_animation_controller_->SetInkDropSize(
-      gfx::Size(kInkDropLargeSize, kInkDropLargeSize),
-      kInkDropLargeCornerRadius,
-      gfx::Size(kInkDropSmallSize, kInkDropSmallSize),
+  GetInkDropDelegate()->SetInkDropSize(
+      kInkDropLargeSize, kInkDropLargeCornerRadius, kInkDropSmallSize,
       kInkDropSmallCornerRadius);
 
   // We also listen for browser theme changes on linux because a switch from or
   // to GTK requires that we regrab our browser action images.
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       content::Source<ThemeService>(
           ThemeServiceFactory::GetForProfile(profile_)));
 
@@ skipping 29 matching lines @@
 
   image()->SetFillsBoundsOpaquely(true);
   image()->SetPaintToLayer(false);
   SetPaintToLayer(false);
 }
 
 gfx::Point ToolbarActionView::CalculateInkDropCenter() const {
   return GetLocalBounds().CenterPoint();
 }
 
+views::InkDropDelegate* ToolbarActionView::GetInkDropDelegate() const {
+  return ink_drop_delegate_.get();
+}
+
 gfx::Size ToolbarActionView::GetPreferredSize() const {
   return gfx::Size(ToolbarActionsBar::IconWidth(false),
                    ToolbarActionsBar::IconHeight());
 }
 
-void ToolbarActionView::Layout() {
-  MenuButton::Layout();
-  ink_drop_animation_controller_->SetInkDropCenter(CalculateInkDropCenter());
-}
-
 bool ToolbarActionView::OnMousePressed(const ui::MouseEvent& event) {
   // views::MenuButton actions are only triggered by left mouse clicks.
-  if (event.IsLeftMouseButton()) {
-    ink_drop_animation_controller_->AnimateToState(
-        views::InkDropState::ACTION_PENDING);
-  }
+  if (event.IsOnlyLeftMouseButton())

[bruthig, 2015/11/20 16:25:33]

Should this be calling 'MenuButton::ShouldEnterPushedState(event)' instead of
'event.IsOnlyLeftMouseButton()'? Or perhaps we can initiate the ACTION_PENDING
animation in a 'StateChanged()' override.

I just don't want this logic to drift from MenuButton::ShouldEnterPushedState().

[varkha, 2015/11/20 17:48:26]

Probably yes to the first question and yes, this will get hopefully better when
we tackle the state model.

+    GetInkDropDelegate()->OnAction(views::InkDropState::ACTION_PENDING);
   return MenuButton::OnMousePressed(event);
 }
 
 void ToolbarActionView::OnGestureEvent(ui::GestureEvent* event) {
-  // TODO(varkha): refactor similar implementations in ToolbarButton,
-  // FindBarButton and here.
   if (menu_) {
     // While dropdown menu is showing the button should not handle gestures.
     event->StopPropagation();
     return;
   }
-
   MenuButton::OnGestureEvent(event);
-
-  views::InkDropState ink_drop_state = views::InkDropState::HIDDEN;
-  switch (event->type()) {
-    case ui::ET_GESTURE_TAP_DOWN:
-      ink_drop_state = views::InkDropState::ACTION_PENDING;
-      // The ui::ET_GESTURE_TAP_DOWN event needs to be marked as handled so that
-      // subsequent events for the gesture are sent to |this|.
-      event->SetHandled();
-      break;
-    case ui::ET_GESTURE_LONG_PRESS:
-      ink_drop_state = views::InkDropState::SLOW_ACTION_PENDING;
-      break;
-    case ui::ET_GESTURE_LONG_TAP:
-      ink_drop_state = views::InkDropState::SLOW_ACTION;
-      break;
-    case ui::ET_GESTURE_SCROLL_BEGIN:
-    case ui::ET_GESTURE_END:
-      ink_drop_state = views::InkDropState::HIDDEN;
-      break;
-    default:
-      return;
-  }
-
-  views::InkDropState current_ink_drop_state =
-      ink_drop_animation_controller_->GetInkDropState();
-
-  if (ink_drop_state == views::InkDropState::HIDDEN &&
-      (current_ink_drop_state == views::InkDropState::QUICK_ACTION ||
-       current_ink_drop_state == views::InkDropState::SLOW_ACTION ||
-       current_ink_drop_state == views::InkDropState::DEACTIVATED)) {
-    // These InkDropStates automatically transition to the HIDDEN state so we
-    // don't make an explicit call. Explicitly animating to HIDDEN in this case
-    // would prematurely pre-empt these animations.
-    return;
-  }
-  ink_drop_animation_controller_->AnimateToState(ink_drop_state);
 }
 
 void ToolbarActionView::OnDragDone() {
-  ink_drop_animation_controller_->AnimateToState(views::InkDropState::HIDDEN);
   views::MenuButton::OnDragDone();
   delegate_->OnToolbarActionViewDragDone();
 }
 
 void ToolbarActionView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && !called_register_command_ && GetFocusManager()) {
     view_controller_->RegisterCommand();
     called_register_command_ = true;
   }
 
   MenuButton::ViewHierarchyChanged(details);
 }
 
 void ToolbarActionView::GetAccessibleState(ui::AXViewState* state) {
   views::MenuButton::GetAccessibleState(state);
   state->role = ui::AX_ROLE_BUTTON;
 }
 
 void ToolbarActionView::OnMenuButtonClicked(views::View* sender,
                                             const gfx::Point& point) {
   if (!view_controller_->IsEnabled(GetCurrentWebContents())) {
     // We should only get a button pressed event with a non-enabled action if
     // the left-click behavior should open the menu.
     DCHECK(view_controller_->DisabledClickOpensMenu());
     context_menu_controller()->ShowContextMenuForView(this, point,
                                                       ui::MENU_SOURCE_NONE);
   } else {
-    ink_drop_animation_controller_->AnimateToState(
-        views::InkDropState::QUICK_ACTION);
     view_controller_->ExecuteAction(true);
   }
 }
 
-void ToolbarActionView::OnMenuButtonClickCanceled(views::View* sender) {
-  ink_drop_animation_controller_->AnimateToState(views::InkDropState::HIDDEN);
-}
-
 void ToolbarActionView::UpdateState() {
   content::WebContents* web_contents = GetCurrentWebContents();
   if (SessionTabHelper::IdForTab(web_contents) < 0)
     return;
 
   if (!view_controller_->IsEnabled(web_contents) &&
       !view_controller_->DisabledClickOpensMenu()) {
       SetState(views::CustomButton::STATE_DISABLED);
   } else if (state() == views::CustomButton::STATE_DISABLED) {
     SetState(views::CustomButton::STATE_NORMAL);
@@ skipping 138 matching lines @@
       views::MenuRunner::HAS_MNEMONICS | views::MenuRunner::CONTEXT_MENU;
   if (delegate_->ShownInsideMenu())
     run_types |= views::MenuRunner::IS_NESTED;
 
   // RunMenuAt expects a nested menu to be parented by the same widget as the
   // already visible menu, in this case the Chrome menu.
   views::Widget* parent = delegate_->ShownInsideMenu() ?
       delegate_->GetOverflowReferenceView()->GetWidget() :
       GetWidget();
 
-  ink_drop_animation_controller_->AnimateToState(
-      views::InkDropState::ACTIVATED);
+  GetInkDropDelegate()->OnAction(views::InkDropState::ACTIVATED);
 
   views::MenuModelAdapter adapter(context_menu_model);
   menu_ = adapter.CreateMenu();
   menu_runner_.reset(new views::MenuRunner(menu_, run_types));
 
   if (context_menu_callback)
     context_menu_callback->Run(this);
   if (menu_runner_->RunMenuAt(parent, this, gfx::Rect(screen_loc, size()),
                               views::MENU_ANCHOR_TOPLEFT,
                               source_type) == views::MenuRunner::MENU_DELETED) {
     menu_ = nullptr;
     return;
   }
-  ink_drop_animation_controller_->AnimateToState(
-      views::InkDropState::DEACTIVATED);
+  GetInkDropDelegate()->OnAction(views::InkDropState::DEACTIVATED);
 
   menu_runner_.reset();
   menu_ = nullptr;
   context_menu_owner = nullptr;
   view_controller_->OnContextMenuClosed();
 
   // If another extension action wants to show its context menu, allow it to.
   if (!followup_context_menu_task_.is_null()) {
     base::Closure task = followup_context_menu_task_;
     followup_context_menu_task_ = base::Closure();
@@ skipping 14 matching lines @@
     if (menu_controller->in_nested_run()) {
       // There is another menu showing. Close the outermost menu (since we are
       // shown in the same menu, we don't want to close the whole thing).
       menu_controller->Cancel(views::MenuController::EXIT_OUTERMOST);
       return true;
     }
   }
 
   return false;
 }