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

ui/views/controls/button/menu_button_unittest.cc

 // Copyright 2014 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/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
+#include "ui/views/animation/test/test_ink_drop_delegate.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/wm/public/drag_drop_client.h"
 #endif
 
 using base::ASCIIToUTF16;
 
 namespace views {
+class InkDropDelegate;
+
+namespace test {
+
+// A MenuButton subclass that provides access to some MenuButton internals.
+class TestMenuButton : public MenuButton {
+ public:
+  explicit TestMenuButton(MenuButtonListener* menu_button_listener)
+      : MenuButton(base::string16(ASCIIToUTF16("button")),
+                   menu_button_listener,
+                   false) {}
+
+  ~TestMenuButton() override {}
+
+  // Accessors to protected MenuButton methods.
+  void set_ink_drop_delegate(InkDropDelegate* ink_drop_delegate) {
+    MenuButton::set_ink_drop_delegate(ink_drop_delegate);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestMenuButton);
+};
 
 class MenuButtonTest : public ViewsTestBase {
  public:
   MenuButtonTest() : widget_(nullptr), button_(nullptr) {}
   ~MenuButtonTest() override {}
 
   void TearDown() override {
     generator_.reset();
     if (widget_ && !widget_->IsClosed())
       widget_->Close();
 
     ViewsTestBase::TearDown();
   }
 
   Widget* widget() { return widget_; }
-  MenuButton* button() { return button_; }
+  TestMenuButton* button() { return button_; }
   ui::test::EventGenerator* generator() { return generator_.get(); }
 
  protected:
   // Creates a MenuButton with no button listener.
   void CreateMenuButtonWithNoListener() { CreateMenuButton(nullptr); }
 
   // Creates a MenuButton with a MenuButtonListener. In this case, when the
   // MenuButton is pushed, it notifies the MenuButtonListener to open a
   // drop-down menu.
   void CreateMenuButtonWithMenuButtonListener(
       MenuButtonListener* menu_button_listener) {
     CreateMenuButton(menu_button_listener);
   }
 
  private:
   void CreateMenuButton(MenuButtonListener* menu_button_listener) {
     CreateWidget();
     generator_.reset(new ui::test::EventGenerator(GetContext(),
         widget_->GetNativeWindow()));
     // Set initial mouse location in a consistent way so that the menu button we
     // are about to create initializes its hover state in a consistent manner.
     generator_->set_current_location(gfx::Point(10, 10));
 
-    const base::string16 label(ASCIIToUTF16("button"));
-    button_ = new MenuButton(label, menu_button_listener, false);
+    button_ = new TestMenuButton(menu_button_listener);
     button_->SetBoundsRect(gfx::Rect(0, 0, 200, 20));
     widget_->SetContentsView(button_);
 
     widget_->Show();
   }
 
   void CreateWidget() {
     DCHECK(!widget_);
 
     widget_ = new Widget;
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     widget_->Init(params);
   }
 
   Widget* widget_;
-  MenuButton* button_;
+  TestMenuButton* button_;
   scoped_ptr<ui::test::EventGenerator> generator_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuButtonTest);
 };
 
 class TestButtonListener : public ButtonListener {
  public:
   TestButtonListener()
       : last_sender_(nullptr),
         last_sender_state_(Button::STATE_NORMAL),
@@ skipping 38 matching lines @@
   View* last_source() { return last_source_; }
   Button::ButtonState last_source_state() { return last_source_state_; }
 
  private:
   View* last_source_;
   Button::ButtonState last_source_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMenuButtonListener);
 };
 
+// A MenuButtonListener that will acquire a PressedLock in the
+// OnMenuButtonClicked() method and optionally release it as well.
+class PressStateMenuButtonListener : public MenuButtonListener {
+ public:
+  explicit PressStateMenuButtonListener(bool release_lock)
+      : menu_button_(nullptr), release_lock_(release_lock) {}
+
+  ~PressStateMenuButtonListener() override {}
+
+  void set_menu_button(MenuButton* menu_button) { menu_button_ = menu_button; }
+
+  void OnMenuButtonClicked(MenuButton* source,
+                           const gfx::Point& point,
+                           const ui::Event* event) override {
+    pressed_lock_.reset(new MenuButton::PressedLock(menu_button_));
+    if (release_lock_)
+      pressed_lock_.reset();
+  }
+
+ private:
+  MenuButton* menu_button_;
+
+  scoped_ptr<MenuButton::PressedLock> pressed_lock_;
+
+  // The |pressed_lock_| will be released when true.
+  bool release_lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(PressStateMenuButtonListener);
+};
+
 // Basic implementation of a DragController, to test input behaviour for
 // MenuButtons that can be dragged.
 class TestDragController : public DragController {
  public:
   TestDragController() {}
   ~TestDragController() override {}
 
   void WriteDragDataForView(View* sender,
                             const gfx::Point& press_pt,
                             ui::OSExchangeData* data) override {}
@@ skipping 129 matching lines @@
 
   generator()->ClickLeftButton();
 
   // Check that MenuButton has notified the listener, while it was in pressed
   // state.
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 // Test that the MenuButton stays pressed while there are any PressedLocks.
-TEST_F(MenuButtonTest, MenuButtonPressedLock) {
+TEST_F(MenuButtonTest, ButtonStateForMenuButtonsWithPressedLocks) {
   CreateMenuButtonWithNoListener();
 
   // Move the mouse over the button; the button should be in a hovered state.
   generator()->MoveMouseTo(gfx::Point(10, 10));
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   // Introduce a PressedLock, which should make the button pressed.
   scoped_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
@@ skipping 67 matching lines @@
   button()->set_drag_controller(&drag_controller);
 
   generator()->PressLeftButton();
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 
   generator()->ReleaseLeftButton();
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
+TEST_F(MenuButtonTest, InkDropStateForMenuButtonActivationsWithoutListener) {
+  CreateMenuButtonWithNoListener();
+  TestInkDropDelegate ink_drop_delegate;
+  ink_drop_delegate.OnAction(InkDropState::ACTION_PENDING);
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+  button()->Activate(nullptr);
+
+  EXPECT_EQ(InkDropState::HIDDEN, ink_drop_delegate.state());
+}
+
+TEST_F(MenuButtonTest,
+       InkDropStateForMenuButtonActivationsWithListenerThatDoesntAcquireALock) {
+  TestMenuButtonListener menu_button_listener;
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+  button()->Activate(nullptr);
+
+  EXPECT_EQ(InkDropState::QUICK_ACTION, ink_drop_delegate.state());
+}
+
+TEST_F(
+    MenuButtonTest,
+    InkDropStateForMenuButtonActivationsWithListenerThatDontReleaseAllLocks) {
+  PressStateMenuButtonListener menu_button_listener(false);
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  menu_button_listener.set_menu_button(button());
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+  button()->Activate(nullptr);
+
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+
+  // Prevent the button from accessing invalid memory during clean up.
+  button()->set_ink_drop_delegate(nullptr);
+}
+
+TEST_F(MenuButtonTest,
+       InkDropStateForMenuButtonActivationsWithListenerThatReleaseAllLocks) {
+  PressStateMenuButtonListener menu_button_listener(true);
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  menu_button_listener.set_menu_button(button());
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+  button()->Activate(nullptr);
+
+  EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop_delegate.state());
+}
+
+TEST_F(MenuButtonTest, InkDropStateForMenuButtonsWithPressedLocks) {
+  CreateMenuButtonWithNoListener();
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+
+  scoped_ptr<MenuButton::PressedLock> pressed_lock1(
+      new MenuButton::PressedLock(button()));
+
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+
+  scoped_ptr<MenuButton::PressedLock> pressed_lock2(
+      new MenuButton::PressedLock(button()));
+
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+
+  pressed_lock1.reset();
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+
+  pressed_lock2.reset();
+  EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop_delegate.state());
+}
+
+// Verifies only one ink drop animation is triggered when multiple PressedLocks
+// are attached to a MenuButton.
+TEST_F(MenuButtonTest, OneInkDropAnimationForReentrantPressedLocks) {
+  CreateMenuButtonWithNoListener();
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+
+  scoped_ptr<MenuButton::PressedLock> pressed_lock1(
+      new MenuButton::PressedLock(button()));
+
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+  ink_drop_delegate.OnAction(InkDropState::ACTION_PENDING);
+
+  scoped_ptr<MenuButton::PressedLock> pressed_lock2(
+      new MenuButton::PressedLock(button()));
+
+  EXPECT_EQ(InkDropState::ACTION_PENDING, ink_drop_delegate.state());
+}
+
+// Verifies the InkDropState is left as ACTIVATED if a PressedLock is active
+// before another Activation occurs.
+TEST_F(MenuButtonTest,
+       InkDropStateForMenuButtonWithPressedLockBeforeActivation) {
+  TestMenuButtonListener menu_button_listener;
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  TestInkDropDelegate ink_drop_delegate;
+  button()->set_ink_drop_delegate(&ink_drop_delegate);
+  MenuButton::PressedLock lock(button());
+
+  button()->Activate(nullptr);
+
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
+}
+
 #if defined(USE_AURA)
 
 // Tests that the MenuButton does not become pressed if it can be dragged, and a
 // DragDropClient is processing the events.
 TEST_F(MenuButtonTest, DraggableMenuButtonDoesNotActivateOnDrag) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   TestDragController drag_controller;
   button()->set_drag_controller(&drag_controller);
 
@@ skipping 55 matching lines @@
 
   generator()->MoveTouch(gfx::Point(10, 30));
   generator()->ReleaseTouch();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 }
 
 #endif  // !defined(OS_MACOSX) || defined(USE_AURA)
 
 }  // namespace views
+}  // namespace test