Moved AppMenu ACTIVATED/DEACTIVATED ink drop handling in to MenuButton.

ui/views/controls/button/menu_button.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 "ui/views/controls/button/menu_button.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 54 matching lines @@
 MenuButton::MenuButton(const base::string16& text,
                        MenuButtonListener* menu_button_listener,
                        bool show_menu_marker)
     : LabelButton(nullptr, text),
       menu_offset_(kDefaultMenuOffsetX, kDefaultMenuOffsetY),
       listener_(menu_button_listener),
       show_menu_marker_(show_menu_marker),
       menu_marker_(ui::ResourceBundle::GetSharedInstance()
                        .GetImageNamed(IDR_MENU_DROPARROW)
                        .ToImageSkia()),
-      destroyed_flag_(NULL),
+      destroyed_flag_(nullptr),
       pressed_lock_count_(0),
+      increment_pressed_lock_called_(nullptr),
       should_disable_after_press_(false),
       weak_factory_(this) {
   SetHorizontalAlignment(gfx::ALIGN_LEFT);
 }
 
 MenuButton::~MenuButton() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 }
 
@@ skipping 23 matching lines @@
     if (max_x_coordinate && max_x_coordinate <= menu_position.x())
       menu_position.set_x(max_x_coordinate - 1);
 
     // We're about to show the menu from a mouse press. By showing from the
     // mouse press event we block RootView in mouse dispatching. This also
     // appears to cause RootView to get a mouse pressed BEFORE the mouse
     // release is seen, which means RootView sends us another mouse press no
     // matter where the user pressed. To force RootView to recalculate the
     // mouse target during the mouse press we explicitly set the mouse handler
     // to NULL.
-    static_cast<internal::RootView*>(GetWidget()->GetRootView())->
-        SetMouseHandler(NULL);
+    static_cast<internal::RootView*>(GetWidget()->GetRootView())
+        ->SetMouseHandler(nullptr);
 
     bool destroyed = false;
     destroyed_flag_ = &destroyed;
 
+    DCHECK(increment_pressed_lock_called_ == nullptr);
+    // Observe if IncrementPressedLocked() was called so we can trigger the
+    // correct ink drop animations.
+    bool increment_pressed_lock_called = false;
+    increment_pressed_lock_called_ = &increment_pressed_lock_called;
+
     // We don't set our state here. It's handled in the MenuController code or
     // by our click listener.
-
-    if (ink_drop_delegate())
-      ink_drop_delegate()->OnAction(InkDropState::QUICK_ACTION);
     listener_->OnMenuButtonClicked(this, menu_position, event);
 
     if (destroyed) {
       // The menu was deleted while showing. Don't attempt any processing.
       return false;
     }
 
-    destroyed_flag_ = NULL;
+    increment_pressed_lock_called_ = nullptr;
+    destroyed_flag_ = nullptr;
 
     menu_closed_time_ = TimeTicks::Now();
 
+    if (ink_drop_delegate() && !increment_pressed_lock_called &&
+        pressed_lock_count_ == 0) {
+      ink_drop_delegate()->OnAction(InkDropState::QUICK_ACTION);
+    }
+
     // We must return false here so that the RootView does not get stuck
     // sending all mouse pressed events to us instead of the appropriate
     // target.
     return false;
   }
+
+  if (ink_drop_delegate())
+    ink_drop_delegate()->OnAction(InkDropState::HIDDEN);
   return true;
 }
 
 bool MenuButton::IsTriggerableEventType(const ui::Event& event) {
   if (event.IsMouseEvent()) {
     const ui::MouseEvent& mouseev = static_cast<const ui::MouseEvent&>(event);
     // Active on left mouse button only, to prevent a menu from being activated
     // when a right-click would also activate a context menu.
     if (!mouseev.IsOnlyLeftMouseButton())
       return false;
@@ skipping 36 matching lines @@
   return kViewClassName;
 }
 
 bool MenuButton::OnMousePressed(const ui::MouseEvent& event) {
   if (request_focus_on_press())
     RequestFocus();
   if (state() != STATE_DISABLED && HitTestPoint(event.location()) &&
       IsTriggerableEventType(event)) {
     if (IsTriggerableEvent(event))
       return Activate(&event);
-    if (ink_drop_delegate())
-      ink_drop_delegate()->OnAction(InkDropState::ACTION_PENDING);
   }
   return true;
 }
 
 void MenuButton::OnMouseReleased(const ui::MouseEvent& event) {
   if (state() != STATE_DISABLED && IsTriggerableEvent(event) &&
       HitTestPoint(event.location()) && !InDrag()) {
     Activate(&event);
   } else {
     if (ink_drop_delegate())
@@ skipping 137 matching lines @@
 }
 
 void MenuButton::NotifyClick(const ui::Event& event) {
   // We don't forward events to the normal button listener, instead using the
   // MenuButtonListener.
   Activate(&event);
 }
 
 void MenuButton::IncrementPressedLocked() {
   ++pressed_lock_count_;
+  if (increment_pressed_lock_called_)
+    *increment_pressed_lock_called_ = true;
   should_disable_after_press_ = state() == STATE_DISABLED;
+  if (state() != STATE_PRESSED && ink_drop_delegate())
+    ink_drop_delegate()->OnAction(InkDropState::ACTIVATED);
   SetState(STATE_PRESSED);
 }
 
 void MenuButton::DecrementPressedLocked() {
   --pressed_lock_count_;
   DCHECK_GE(pressed_lock_count_, 0);
 
   // If this was the last lock, manually reset state to the desired state.
   if (pressed_lock_count_ == 0) {
     ButtonState desired_state = STATE_NORMAL;
     if (should_disable_after_press_) {
       desired_state = STATE_DISABLED;
       should_disable_after_press_ = false;
     } else if (ShouldEnterHoveredState()) {
       desired_state = STATE_HOVERED;
     }
     SetState(desired_state);
+    if (ink_drop_delegate() && state() != STATE_PRESSED)
+      ink_drop_delegate()->OnAction(InkDropState::DEACTIVATED);
   }
 }
 
 int MenuButton::GetMaximumScreenXCoordinate() {
   if (!GetWidget()) {
     NOTREACHED();
     return 0;
   }
 
   gfx::Rect monitor_bounds = GetWidget()->GetWorkAreaBoundsInScreen();
   return monitor_bounds.right() - 1;
 }
 
 }  // namespace views