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 2040 matching lines @@
   bool IsVisible() const override { return is_visible_; }
   bool GetTargetVisibility() const override { return target_visibility_; }
 
  private:
   bool is_visible_ = false;
   bool target_visibility_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TestAppListPresenter);
 };
 
+// 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 that returns a TestAppListPresenter as
-// the app list presenter.
-class TestAppListShellDelegate : public TestShellDelegate {
+// the app list presenter and a TestShellMenuModel for the shell context menu.
+class TestShelfViewShellDelegate : public TestShellDelegate {
  public:
-  TestAppListShellDelegate()
+  TestShelfViewShellDelegate()
       : app_list_presenter_(new TestAppListPresenter()) {}
-  ~TestAppListShellDelegate() override {}
+  ~TestShelfViewShellDelegate() override {}
 
   TestAppListPresenter* app_list_presenter() const {
     return app_list_presenter_.get();
   }
 
   // TestShellDelegate:
+  ui::MenuModel* CreateContextMenu(WmShelf* wm_shelf,
+                                   const ShelfItem* item) override {
+    return new TestShellMenuModel;
+  }
   app_list::AppListPresenter* GetAppListPresenter() override {
     return app_list_presenter();
   }
 
  private:
   std::unique_ptr<TestAppListPresenter> app_list_presenter_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestAppListShellDelegate);
+  DISALLOW_COPY_AND_ASSIGN(TestShelfViewShellDelegate);
+};
+
+// 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() {
+    mock_task_runner_->ClearPendingTasks();

[bruthig, 2016/08/25 19:18:35]

It might be a good idea to DCHECK_EQ(mock_task_runner_,
base::MessageLoop::current()->task_runner()) here to make sure we don't have
multiple clients who aren't playing nice.

[mohsen, 2016/08/30 18:03:32]

Done.

+    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 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;
+    shell_delegate_ = new TestShelfViewShellDelegate;
     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 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_));
+  }
+
   void ShowAppList() {
     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() {
     shell_delegate_->app_list_presenter()->Dismiss();
     // Similar to real AppListPresenter, notify button that the app list is
     // dismissed.
     app_list_button_->OnAppListDismissed();
   }
 
   void FinishAppListVisibilityChange() {
     shell_delegate_->app_list_presenter()->FinishVisibilityChange();
   }
 
-  TestAppListShellDelegate* shell_delegate_ = nullptr;  // Owned by Shell.
+  TestShelfViewShellDelegate* 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;
+  OverflowButton* overflow_button_ = nullptr;
+  InkDropSpy* overflow_button_ink_drop_ = nullptr;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfViewInkDropTest);
 };
 
 // Tests that changing visibility of the app list transitions app list button's
 // ink drop states correctly.
 TEST_F(ShelfViewInkDropTest, AppListButtonWhenVisibilityChanges) {
   InitAppListButtonInkDrop();
 
@@ skipping 372 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));
 }
 
+// Tests ink drop state transitions for the overflow button when the overflow
+// bubble is shown or hidden.
+TEST_F(ShelfViewInkDropTest, OverflowButtonOnOverflowBubbleShowHide) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&

[bruthig, 2016/08/25 19:18:35]

I know you are just copying this style of expectation from other tests but it is
not a great format because the it makes it impossible to know which condition is
actually false in the output (see example below).  I think it would be better to
re-write these as:

ASSERT_TRUE(test_api_->overflow_bubble());
EXPECT_TRUE(test_api_->overflow_bubble()->IsShowing());

Example expectation:

EXPECT_TRUE(foo && bar);

Example Log:

Value of: foo && bar
  Actual: false
Expected: true

[mohsen, 2016/08/30 18:03:32]

I updated this for EXPECT_TRUE(foo && bar) cases, but I don't think we can do
that for EXPECT_FALSE(foo && bar) (similarly, EXPECT_TRUE(foo || bar)).

[bruthig, 2016/09/01 16:12:54]

Acknowledged.

+               test_api_->overflow_bubble()->IsShowing());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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(),

[bruthig, 2016/08/25 19:18:35]

I really like how these expectations work with the matchers!!

+              ElementsAre(views::InkDropState::DEACTIVATED));
+}
+
+// Tests ink drop state transitions for the overflow button when the user clicks
+// on it.
+TEST_F(ShelfViewInkDropTest, OverflowButtonMouseActivate) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  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));
+
+  EXPECT_TRUE(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.
+TEST_F(ShelfViewInkDropTest, OverflowButtonMouseDragOut) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  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.MoveMouseBy(overflow_button_->width(), 0);
+  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(ShelfViewInkDropTest, OverflowButtonMouseDragOutAndBack) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  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.MoveMouseBy(overflow_button_->width(), 0);
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  generator.MoveMouseBy(-overflow_button_->width(), 0);
+  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));
+
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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(ShelfViewInkDropTest, OverflowButtonMouseContextMenu) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(mouse_location);
+
+  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());
+}
+
+// Tests ink drop state transitions for the overflow button when it is active
+// and the user clicks on it.
+TEST_F(ShelfViewInkDropTest, OverflowButtonActiveMouseDeactivate) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(mouse_location);
+
+  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(ShelfViewInkDropTest, OverflowButtonActiveMouseDragOut) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(mouse_location);
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseBy(overflow_button_->width(), 0);
+  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());
+
+  EXPECT_TRUE(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 and back.
+TEST_F(ShelfViewInkDropTest, OverflowButtonActiveMouseDragOutAndBack) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(mouse_location);
+
+  generator.PressLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseBy(overflow_button_->width(), 0);
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  generator.MoveMouseBy(-overflow_button_->width(), 0);
+  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(ShelfViewInkDropTest, OverflowButtonActiveMouseContextMenu) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point mouse_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(mouse_location);
+
+  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());
+
+  EXPECT_TRUE(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(ShelfViewInkDropTest, OverflowButtonTouchActivate) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  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));
+
+  EXPECT_TRUE(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.
+TEST_F(ShelfViewInkDropTest, OverflowButtonTouchDragOut) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  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));
+
+  touch_location.Offset(overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  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(ShelfViewInkDropTest, OverflowButtonTouchDragOutAndBack) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  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));
+
+  touch_location.Offset(overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  touch_location.Offset(-overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  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(ShelfViewInkDropTest, OverflowButtonTouchContextMenu) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  EXPECT_FALSE(test_api_->overflow_bubble() &&
+               test_api_->overflow_bubble()->IsShowing());
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  {
+    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));

[bruthig, 2016/08/25 19:18:35]

I kind of expect the ALTERNATE_ACTION_PENDING to be followed by a
ALTERNATE_ACTION_TRIGGERED here when showing the context menu.  How much of a
change would that be?

It might be difficult to do, and not worthwhile, because it should behave nicely
when showing the context menu when the button is already activated.

[mohsen, 2016/08/30 18:03:32]

Currently, ALTERNATE_ACTION_PENDING is used on a long-press and
ALTERNATE_ACTION_TRIGGERED is used on the following long-tap (i.e., when the
user lifts the finger from the screen). It kind of makes sense to me. Here, the
context menu interrupts the long-tap action, so it makes sense to me that no
ALTERNATE_ACTION_TRIGGERED is seen. WDYT?

[bruthig, 2016/09/01 16:12:54]

Seems reasonable, if we wanted it to perform an ALTERNATE_ACTION_TRIGGERED we
would have to update CustomButton::ShowContextMenu() and that would be too much
of a change to include here.

+
+    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 it is active
+// and the user taps on it.
+TEST_F(ShelfViewInkDropTest, OverflowButtonActiveTouchDeactivate) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  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(ShelfViewInkDropTest, OverflowButtonActiveTouchDragOut) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  touch_location.Offset(overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  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());
+
+  EXPECT_TRUE(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 and back.
+TEST_F(ShelfViewInkDropTest, OverflowButtonActiveTouchDragOutAndBack) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  touch_location.Offset(overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            overflow_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  touch_location.Offset(-overflow_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  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());
+
+  EXPECT_TRUE(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 long presses on the button to show the context menu.
+TEST_F(ShelfViewInkDropTest, OverflowButtonActiveTouchContextMenu) {
+  InitOverflowButtonInkDrop();
+
+  AddButtonsUntilOverflow();
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+
+  test_api_->ShowOverflowBubble();
+  EXPECT_TRUE(test_api_->overflow_bubble() &&
+              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));
+
+  ui::test::EventGenerator& generator = GetEventGenerator();
+  gfx::Point touch_location =
+      overflow_button_->GetBoundsInScreen().CenterPoint();
+  generator.set_current_location(touch_location);
+
+  {
+    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());
+
+    EXPECT_TRUE(test_api_->overflow_bubble() &&
+                test_api_->overflow_bubble()->IsShowing());
+  }
+}
+
+#endif  // !defined(OS_WIN)
+
 }  // namespace test
 }  // namespace ash