Implemented prototype for new ink drop specs.

chrome/browser/ui/views/toolbar/toolbar_button.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_button.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 61 matching lines @@
       int inset = provider->GetDisplayProperty(
           ThemeProperties::PROPERTY_TOOLBAR_BUTTON_BORDER_INSET);
       size.Enlarge(2 * inset, 2 * inset);
     }
   }
   return size;
 }
 
 void ToolbarButton::Layout() {
   LabelButton::Layout();
-  LayoutInkDrop();
+
+  // Sizes for the the ink drop.
+  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),
+      kInkDropSmallCornerRadius);
+  ink_drop_animation_controller_->SetInkDropCenter(CalculateInkDropCenter());
 }
 
 bool ToolbarButton::OnMousePressed(const ui::MouseEvent& event) {
   if (enabled() && ShouldShowMenu() &&
       IsTriggerableEvent(event) && HitTestPoint(event.location())) {
     // Store the y pos of the mouse coordinates so we can use them later to
     // determine if the user dragged the mouse down (which should pop up the
     // drag down menu immediately, instead of waiting for the timer)
     y_position_on_lbuttondown_ = event.y();
 
     // Schedule a task that will show the menu.
     const int kMenuTimerDelay = 500;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&ToolbarButton::ShowDropDownMenu,
                               show_menu_factory_.GetWeakPtr(),
                               ui::GetMenuSourceTypeForEvent(event)),
         base::TimeDelta::FromMilliseconds(kMenuTimerDelay));
   }
 
-  ink_drop_animation_controller_->AnimateToState(
-      views::InkDropState::ACTION_PENDING);
+  // views::Button actions are only triggered by left and middle mouse clicks.
+  if (event.IsLeftMouseButton() || event.IsMiddleMouseButton()) {
+    ink_drop_animation_controller_->AnimateToState(
+        views::InkDropState::ACTION_PENDING);
+  }
 
   return LabelButton::OnMousePressed(event);
 }
 
 bool ToolbarButton::OnMouseDragged(const ui::MouseEvent& event) {
   bool result = LabelButton::OnMouseDragged(event);
 
   if (show_menu_factory_.HasWeakPtrs()) {
     // If the mouse is dragged to a y position lower than where it was when
     // clicked then we should not wait for the menu to appear but show
@@ skipping 41 matching lines @@
 
   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;
+      ink_drop_state = views::InkDropState::SLOW_ACTION_PENDING;
       break;
     case ui::ET_GESTURE_TAP:
       ink_drop_state = views::InkDropState::QUICK_ACTION;
       break;
+    case ui::ET_GESTURE_LONG_TAP:
+      ink_drop_state = views::InkDropState::SLOW_ACTION;
+      break;
     case ui::ET_GESTURE_END:
     case ui::ET_GESTURE_TAP_CANCEL:
       ink_drop_state = views::InkDropState::HIDDEN;
       break;
     default:
       return;
   }
   ink_drop_animation_controller_->AnimateToState(ink_drop_state);
 }
 
@@ skipping 50 matching lines @@
 bool ToolbarButton::ShouldEnterPushedState(const ui::Event& event) {
   // Enter PUSHED state on press with Left or Right mouse button or on taps.
   // Remain in this state while the context menu is open.
   return event.type() == ui::ET_GESTURE_TAP ||
          event.type() == ui::ET_GESTURE_TAP_DOWN ||
          (event.IsMouseEvent() && ((ui::EF_LEFT_MOUSE_BUTTON |
              ui::EF_RIGHT_MOUSE_BUTTON) & event.flags()) != 0);
 }
 
 bool ToolbarButton::ShouldShowMenu() {
-  return model_ != NULL;
+  return model_ != nullptr;
 }
 
 void ToolbarButton::ShowDropDownMenu(ui::MenuSourceType source_type) {
   if (!ShouldShowMenu())
     return;
 
   gfx::Rect lb = GetLocalBounds();
 
   // Both the menu position and the menu anchor type change if the UI layout
   // is right-to-left.
@@ skipping 24 matching lines @@
   int left_bound = display.bounds().x();
 #endif
   if (menu_position.x() < left_bound)
     menu_position.set_x(left_bound);
 
   // Make the button look depressed while the menu is open.
   SetState(STATE_PRESSED);
 
   menu_showing_ = true;
 
+  views::MenuRunner::RunResult result = views::MenuRunner::MENU_DELETED;

[Peter Kasting, 2015/09/09 22:50:46]

Nit: For clarity, I'd move this line to be between the comment below and the
subsequent conditional, and I'd omit the initial value so it's clear both arms
must set this.

[bruthig, 2015/09/10 14:57:38]

Done.

+  ink_drop_animation_controller_->AnimateToState(
+      views::InkDropState::ACTIVATED);
+
   // Create and run menu.  Display an empty menu if model is NULL.
   if (model_.get()) {
     views::MenuModelAdapter menu_delegate(model_.get());
     menu_delegate.set_triggerable_event_flags(triggerable_event_flags());
     menu_runner_.reset(new views::MenuRunner(menu_delegate.CreateMenu(),
                                              views::MenuRunner::HAS_MNEMONICS));
-    views::MenuRunner::RunResult result =
-        menu_runner_->RunMenuAt(GetWidget(),
-                                NULL,
-                                gfx::Rect(menu_position, gfx::Size(0, 0)),
-                                views::MENU_ANCHOR_TOPLEFT,
-                                source_type);
-    if (result == views::MenuRunner::MENU_DELETED)
-      return;
+    result = menu_runner_->RunMenuAt(GetWidget(), nullptr,
+                                     gfx::Rect(menu_position, gfx::Size(0, 0)),
+                                     views::MENU_ANCHOR_TOPLEFT, source_type);
   } else {
     views::MenuDelegate menu_delegate;
     views::MenuItemView* menu = new views::MenuItemView(&menu_delegate);
     menu_runner_.reset(
         new views::MenuRunner(menu, views::MenuRunner::HAS_MNEMONICS));
-    views::MenuRunner::RunResult result =
-        menu_runner_->RunMenuAt(GetWidget(),
-                                NULL,
-                                gfx::Rect(menu_position, gfx::Size(0, 0)),
-                                views::MENU_ANCHOR_TOPLEFT,
-                                source_type);
-    if (result == views::MenuRunner::MENU_DELETED)
-      return;
+    result = menu_runner_->RunMenuAt(GetWidget(), nullptr,
+                                     gfx::Rect(menu_position, gfx::Size(0, 0)),
+                                     views::MENU_ANCHOR_TOPLEFT, source_type);
   }
 
-  ink_drop_animation_controller_->AnimateToState(views::InkDropState::HIDDEN);
+  // RunMenuAt() will return MENU_DELETED if the |menu_runner_| was destroyed as
+  // a result of the ToolbarButton's destructor being called.

[Peter Kasting, 2015/09/09 22:50:46]

Nit: You probably don't need this as this ought to be clear to anyone familiar
with menus.  In either case, I'd remove the blank line above this since this is
sort of the final part of "handling running the menu".

[bruthig, 2015/09/10 14:57:38]

Done.

+  if (result == views::MenuRunner::MENU_DELETED)
+    return;
+
+  ink_drop_animation_controller_->AnimateToState(
+      views::InkDropState::DEACTIVATED);
 
   menu_showing_ = false;
 
   // Need to explicitly clear mouse handler so that events get sent
   // properly after the menu finishes running. If we don't do this, then
   // the first click to other parts of the UI is eaten.
-  SetMouseHandler(NULL);
+  SetMouseHandler(nullptr);
 
   // Set the state back to normal after the drop down menu is closed.
   if (state_ != STATE_DISABLED)
     SetState(STATE_NORMAL);
 }
 
-void ToolbarButton::LayoutInkDrop() {
-  ink_drop_animation_controller_->SetInkDropSize(size());
+gfx::Point ToolbarButton::CalculateInkDropCenter() const {
+  return gfx::Point(width() / 2, height() / 2);

[Peter Kasting, 2015/09/09 22:50:46]

Nit: Or just:

  return GetLocalBounds().CenterPoint();

[bruthig, 2015/09/10 14:57:38]

Done.

+}
+
+void ToolbarButton::NotifyClick(const ui::Event& event) {
+  LabelButton::NotifyClick(event);
+  ink_drop_animation_controller_->AnimateToState(
+      views::InkDropState::QUICK_ACTION);
 }
 
 const char* ToolbarButton::GetClassName() const {
   return "ToolbarButton";
 }