Add ink drop ripple to shelf overflow button

ash/shelf/shelf_view_unittest.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 "ash/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/overflow_bubble.h"
 #include "ash/common/shelf/overflow_bubble_view.h"
+#include "ash/common/shelf/overflow_button.h"
 #include "ash/common/shelf/shelf_button.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_icon_observer.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_tooltip_manager.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/web_notification/web_notification_tray.h"
 #include "ash/common/test/material_design_controller_test_api.h"
@@ skipping 10 matching lines @@
 #include "ash/test/test_shelf_item_delegate.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/test/test_system_tray_delegate.h"
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/test_mock_time_task_runner.h"
 #include "base/test/user_action_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/app_list/presenter/app_list_presenter.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
@@ skipping 2073 matching lines @@
 }  // namespace
 
 // Test fixture that forces material design mode in order to test ink drop
 // ripples on shelf.
 class ShelfViewInkDropTest : public ShelfViewTest {
  public:
   ShelfViewInkDropTest() {}
   ~ShelfViewInkDropTest() override {}
 
   void SetUp() override {
-    shell_delegate_ = new TestAppListShellDelegate;
-    ash_test_helper()->set_test_shell_delegate(shell_delegate_);
+    if (!ash_test_helper()->test_shell_delegate()) {
+      shell_delegate_ = new TestAppListShellDelegate;
+      ash_test_helper()->set_test_shell_delegate(shell_delegate_);
+    }
 
     set_material_mode(ash::MaterialDesignController::MATERIAL_EXPERIMENTAL);
 
     ShelfViewTest::SetUp();
   }
 
  protected:
   void InitAppListButtonInkDrop() {
     app_list_button_ = shelf_view_->GetAppListButton();
 
     views::InkDropImpl* ink_drop_impl =
         new views::InkDropImpl(app_list_button_);
     app_list_button_ink_drop_ = new InkDropSpy(base::WrapUnique(ink_drop_impl));
     views::test::InkDropHostViewTestApi(app_list_button_)
         .SetInkDrop(base::WrapUnique(app_list_button_ink_drop_), false);
   }
 
   void InitBrowserButtonInkDrop() {
     browser_button_ = test_api_->GetButton(browser_index_);
 
     views::InkDropImpl* ink_drop_impl = new views::InkDropImpl(browser_button_);
     browser_button_ink_drop_ = new InkDropSpy(base::WrapUnique(ink_drop_impl));
     views::test::InkDropHostViewTestApi(browser_button_)
         .SetInkDrop(base::WrapUnique(browser_button_ink_drop_));
   }
 
   void ShowAppList() {
+    DCHECK(shelf_delegate_);
     shell_delegate_->app_list_presenter()->Show(0);
     // Similar to real AppListPresenter, notify button that the app list is
     // shown.
     app_list_button_->OnAppListShown();
   }
 
   void DismissAppList() {
+    DCHECK(shelf_delegate_);
     shell_delegate_->app_list_presenter()->Dismiss();
     // Similar to real AppListPresenter, notify button that the app list is
     // dismissed.
     app_list_button_->OnAppListDismissed();
   }
 
   void FinishAppListVisibilityChange() {
+    DCHECK(shelf_delegate_);
     shell_delegate_->app_list_presenter()->FinishVisibilityChange();
   }
 
   TestAppListShellDelegate* shell_delegate_ = nullptr;  // Owned by Shell.
 
   AppListButton* app_list_button_ = nullptr;
   InkDropSpy* app_list_button_ink_drop_ = nullptr;
   ShelfButton* browser_button_ = nullptr;
   InkDropSpy* browser_button_ink_drop_ = nullptr;
 
@@ skipping 381 matching lines @@
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
   test_api_->CloseMenu();
   EXPECT_EQ(views::InkDropState::HIDDEN,
             browser_button_ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTIVATED,
                           views::InkDropState::DEACTIVATED));
 }
 
+namespace {
+
+// An empty menu model for shell context menu just to have a menu.
+class TestShellMenuModel : public ui::SimpleMenuModel,
+                           public ui::SimpleMenuModel::Delegate {
+ public:
+  TestShellMenuModel() : ui::SimpleMenuModel(this) {}
+  ~TestShellMenuModel() override {}
+
+ private:
+  // ui::SimpleMenuModel::Delegate:
+  bool IsCommandIdChecked(int command_id) const override { return false; }
+  bool IsCommandIdEnabled(int command_id) const override { return true; }
+  void ExecuteCommand(int command_id, int event_flags) override {}
+
+  DISALLOW_COPY_AND_ASSIGN(TestShellMenuModel);
+};
+
+// A test ShellDelegate implementation for overflow button tests that returns a
+// TestShelfMenuModel for the shell context menu.
+class TestOverflowButtonShellDelegate : public TestShellDelegate {
+ public:
+  TestOverflowButtonShellDelegate() {}
+  ~TestOverflowButtonShellDelegate() override {}
+
+  // TestShellDelegate:
+  ui::MenuModel* CreateContextMenu(WmShelf* wm_shelf,
+                                   const ShelfItem* item) override {
+    // Caller takes ownership of the returned object.
+    return new TestShellMenuModel;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestOverflowButtonShellDelegate);
+};
+
+// A scoped wrapper around TestMockTimeTaskRunner that replaces message loop's
+// task runner with a TestMockTimeTaskRunner and resets it back at the end of
+// the scope.
+class ScopedMockTaskRunnerWrapper {
+ public:
+  ScopedMockTaskRunnerWrapper() {
+    mock_task_runner_ = new base::TestMockTimeTaskRunner;
+    previous_task_runner_ = base::MessageLoop::current()->task_runner();
+    base::MessageLoop::current()->SetTaskRunner(mock_task_runner_);
+  }
+
+  ~ScopedMockTaskRunnerWrapper() {
+    DCHECK_EQ(mock_task_runner_, base::MessageLoop::current()->task_runner());
+    mock_task_runner_->ClearPendingTasks();
+    base::MessageLoop::current()->SetTaskRunner(previous_task_runner_);
+  }
+
+  void FastForwardUntilNoTasksRemain() {
+    mock_task_runner_->FastForwardUntilNoTasksRemain();
+  }
+
+ private:
+  scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> previous_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedMockTaskRunnerWrapper);
+};
+
+}  // namespace
+
+// Test fixture for testing material design ink drop on overflow button.
+class OverflowButtonInkDropTest : public ShelfViewInkDropTest {
+ public:
+  OverflowButtonInkDropTest() {}
+  ~OverflowButtonInkDropTest() override {}
+
+  void SetUp() override {
+    // Shell takes ownership of the test shell delegate.
+    ash_test_helper()->set_test_shell_delegate(
+        new TestOverflowButtonShellDelegate);
+
+    ShelfViewInkDropTest::SetUp();
+
+    InitOverflowButtonInkDrop();
+
+    AddButtonsUntilOverflow();
+    EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+    EXPECT_FALSE(test_api_->overflow_bubble() &&
+                 test_api_->overflow_bubble()->IsShowing());
+  }
+
+ protected:
+  void InitOverflowButtonInkDrop() {
+    overflow_button_ = test_api_->overflow_button();
+
+    views::InkDropImpl* ink_drop_impl =
+        new views::InkDropImpl(overflow_button_);
+    overflow_button_ink_drop_ = new InkDropSpy(base::WrapUnique(ink_drop_impl));
+    views::test::InkDropHostViewTestApi(overflow_button_)
+        .SetInkDrop(base::WrapUnique(overflow_button_ink_drop_));
+  }
+
+  gfx::Point GetScreenPointInsideOverflowButton() const {
+    return overflow_button_->GetBoundsInScreen().CenterPoint();
+  }
+
+  gfx::Point GetScreenPointOutsideOverflowButton() const {
+    gfx::Point point = GetScreenPointInsideOverflowButton();
+    point.Offset(overflow_button_->width(), 0);
+    return point;
+  }
+
+  OverflowButton* overflow_button_ = nullptr;
+  InkDropSpy* overflow_button_ink_drop_ = nullptr;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OverflowButtonInkDropTest);
+};
+
+// Tests ink drop state transitions for the overflow button when the overflow
+// bubble is shown or hidden.
+TEST_F(OverflowButtonInkDropTest, OnOverflowBubbleShowHide) {
+  test_api_->ShowOverflowBubble();
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  test_api_->HideOverflowBubble();
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+}
+
+// Tests ink drop state transitions for the overflow button when the user clicks
+// on it.
+TEST_F(OverflowButtonInkDropTest, MouseActivate) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location = GetScreenPointInsideOverflowButton();
+  generator.MoveMouseTo(mouse_location);
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user
+// presses left mouse button on it and drags it out of the button bounds.
+TEST_F(OverflowButtonInkDropTest, MouseDragOut) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.MoveMouseTo(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user
+// presses left mouse button on it and drags it out of the button bounds and
+// back.
+TEST_F(OverflowButtonInkDropTest, MouseDragOutAndBack) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.MoveMouseTo(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user right
+// clicks on the button to show the context menu.
+TEST_F(OverflowButtonInkDropTest, MouseContextMenu) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressRightButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseRightButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+#if !defined(OS_WIN)
+// There is no ink drop effect for gesture events on Windows.
+
+// Tests ink drop state transitions for the overflow button when the user taps
+// on it.
+TEST_F(OverflowButtonInkDropTest, TouchActivate) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user taps
+// down on it and drags it out of the button bounds.
+TEST_F(OverflowButtonInkDropTest, TouchDragOut) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.MoveTouch(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user taps
+// down on it and drags it out of the button bounds and back.
+TEST_F(OverflowButtonInkDropTest, TouchDragOutAndBack) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  generator.MoveTouch(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  generator.MoveTouch(GetScreenPointInsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when the user long
+// presses on the button to show the context menu.
+TEST_F(OverflowButtonInkDropTest, TouchContextMenu) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  {
+    RunAllPendingInMessageLoop();
+    ScopedMockTaskRunnerWrapper mock_task_runner;
+
+    generator.PressTouch();
+    EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                ElementsAre(views::InkDropState::ACTION_PENDING));
+
+    mock_task_runner.FastForwardUntilNoTasksRemain();
+    EXPECT_EQ(views::InkDropState::HIDDEN,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                ElementsAre(views::InkDropState::ALTERNATE_ACTION_PENDING,
+                            views::InkDropState::HIDDEN));
+
+    generator.ReleaseTouch();
+    EXPECT_EQ(views::InkDropState::HIDDEN,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                IsEmpty());
+
+    EXPECT_FALSE(test_api_->overflow_bubble() &&
+                 test_api_->overflow_bubble()->IsShowing());
+  }
+}
+
+#endif  // !defined(OS_WIN)
+
+// Test fixture for testing material design ink drop on overflow button when it
+// is active.
+class OverflowButtonActiveInkDropTest : public OverflowButtonInkDropTest {
+ public:
+  OverflowButtonActiveInkDropTest() {}
+  ~OverflowButtonActiveInkDropTest() override {}
+
+  void SetUp() override {
+    OverflowButtonInkDropTest::SetUp();
+
+    test_api_->ShowOverflowBubble();
+    ASSERT_TRUE(test_api_->overflow_bubble());
+    EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+    EXPECT_EQ(views::InkDropState::ACTIVATED,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                ElementsAre(views::InkDropState::ACTIVATED));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OverflowButtonActiveInkDropTest);
+};
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user clicks on it.
+TEST_F(OverflowButtonActiveInkDropTest, MouseDeactivate) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user presses left mouse button on it and drags it out of the button
+// bounds.
+TEST_F(OverflowButtonActiveInkDropTest, MouseDragOut) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseTo(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user presses left mouse button on it and drags it out of the button
+// bounds and back.
+TEST_F(OverflowButtonActiveInkDropTest, MouseDragOutAndBack) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseTo(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user right clicks on the button to show the context menu.
+TEST_F(OverflowButtonActiveInkDropTest, MouseContextMenu) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.MoveMouseTo(GetScreenPointInsideOverflowButton());
+
+  generator.PressRightButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseRightButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+#if !defined(OS_WIN)
+// There is no ink drop effect for gesture events on Windows.
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user taps on it.
+TEST_F(OverflowButtonActiveInkDropTest, TouchDeactivate) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED,
+                          views::InkDropState::HIDDEN));
+
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user taps down on it and drags it out of the button bounds.
+TEST_F(OverflowButtonActiveInkDropTest, TouchDragOut) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveTouch(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user taps down on it and drags it out of the button bounds and back.
+TEST_F(OverflowButtonActiveInkDropTest, TouchDragOutAndBack) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveTouch(GetScreenPointOutsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveTouch(GetScreenPointInsideOverflowButton());
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  ASSERT_TRUE(test_api_->overflow_bubble());
+  EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user long presses on the button to show the context menu.
+TEST_F(OverflowButtonActiveInkDropTest, TouchContextMenu) {
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  generator.set_current_location(GetScreenPointInsideOverflowButton());
+
+  {
+    RunAllPendingInMessageLoop();
+    ScopedMockTaskRunnerWrapper mock_task_runner;
+
+    generator.PressTouch();
+    EXPECT_EQ(views::InkDropState::ACTIVATED,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                IsEmpty());
+
+    mock_task_runner.FastForwardUntilNoTasksRemain();
+    EXPECT_EQ(views::InkDropState::ACTIVATED,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                IsEmpty());
+
+    generator.ReleaseTouch();
+    EXPECT_EQ(views::InkDropState::ACTIVATED,
+              overflow_button_ink_drop_->GetTargetInkDropState());
+    EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+                IsEmpty());
+
+    ASSERT_TRUE(test_api_->overflow_bubble());
+    EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());
+  }
+}
+
+#endif  // !defined(OS_WIN)
+
 }  // namespace test
 }  // namespace ash