Add MD ink drop ripple to app list 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/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
+#include "ash/test/ash_test_helper.h"
 #include "ash/test/material_design_controller_test_api.h"
 #include "ash/test/overflow_bubble_view_test_api.h"
 #include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
 #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/compiler_specific.h"
 #include "base/i18n/rtl.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/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"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/views/animation/ink_drop_impl.h"
@@ skipping 1419 matching lines @@
     ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "ShelfView tries to hide on button " << i;
   }
 
   // The tooltip should not hide on the app-list button.
-  views::View* app_list_button = shelf_view_->GetAppListButtonView();
+  AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 
   // The tooltip shouldn't hide if the mouse is in the gap between two buttons.
   gfx::Rect app_button_rect = GetButtonByID(app_button_id)->GetMirroredBounds();
   gfx::Rect platform_button_rect =
       GetButtonByID(platform_button_id)->GetMirroredBounds();
   ASSERT_FALSE(app_button_rect.Intersects(platform_button_rect));
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       gfx::UnionRects(app_button_rect, platform_button_rect).CenterPoint()));
 
   // The tooltip should hide if it's outside of all buttons.
   gfx::Rect all_area;
   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
     ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     all_area.Union(button->GetMirroredBounds());
   }
-  all_area.Union(shelf_view_->GetAppListButtonView()->GetMirroredBounds());
+  all_area.Union(shelf_view_->GetAppListButton()->GetMirroredBounds());
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(all_area.origin()));
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.right() - 1, all_area.bottom() - 1)));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.right(), all_area.y())));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x() - 1, all_area.y())));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.y() - 1)));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.bottom())));
 }
 
 TEST_F(ShelfViewTest, ShouldHideTooltipWithAppListWindowTest) {
   Shell::GetInstance()->ShowAppList(NULL);
   ASSERT_TRUE(Shell::GetInstance()->GetAppListTargetVisibility());
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
   for (int i = 1; i < test_api_->GetButtonCount(); i++) {
     ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "ShelfView tries to hide on button " << i;
   }
 
   // The tooltip should hide on the app-list button.
-  views::View* app_list_button = shelf_view_->GetAppListButtonView();
+  AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 }
 
 // Test that by moving the mouse cursor off the button onto the bubble it closes
 // the bubble.
 TEST_F(ShelfViewTest, ShouldHideTooltipWhenHoveringOnTooltip) {
   ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
   tooltip_manager->set_timer_delay_for_test(0);
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 
   // Move the mouse off any item and check that no tooltip is shown.
   generator.MoveMouseTo(gfx::Point(0, 0));
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Move the mouse over the button and check that it is visible.
-  views::View* app_list_button = shelf_view_->GetAppListButtonView();
+  AppListButton* app_list_button = shelf_view_->GetAppListButton();
   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
   generator.MoveMouseTo(bounds.CenterPoint());
   // Wait for the timer to go off.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Move the mouse cursor slightly to the right of the item. The tooltip should
   // stay open.
   generator.MoveMouseBy(bounds.width() / 2 + 5, 0);
   // Make sure there is no delayed close.
@@ skipping 289 matching lines @@
 
   // Make the added running platform app to be an app shortcut.
   // This app shortcut should be a swapped view in overflow bubble, which is
   // invisible.
   SetShelfItemTypeToAppShortcut(platform_app_id);
   EXPECT_FALSE(GetButtonByID(platform_app_id)->visible());
 }
 
 // Tests that the AppListButton renders as active in response to touches.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedback) {
-  AppListButton* app_list_button =
-      static_cast<AppListButton*>(shelf_view_->GetAppListButtonView());
+  AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   generator.set_current_location(app_list_button->
       GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
   generator.ReleaseTouch();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
   EXPECT_TRUE(Shell::GetInstance()->GetAppListTargetVisibility());
 }
 
 // Tests that a touch that slides out of the bounds of the AppListButton leads
 // to the end of rendering an active state.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedbackCancellation) {
-  AppListButton* app_list_button =
-      static_cast<AppListButton*>(shelf_view_->GetAppListButtonView());
+  AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   generator.set_current_location(app_list_button->
       GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
   gfx::Point moved_point(app_list_button->GetBoundsInScreen().right() + 1,
                          app_list_button->
@@ skipping 78 matching lines @@
     gfx::Rect shelf_bounds = shelf_view_->GetBoundsInScreen();
     EXPECT_TRUE(shelf_bounds.Contains(visible_bounds));
     for (int i = 0; i < test_api_->GetButtonCount(); ++i)
       if (ShelfButton* button = test_api_->GetButton(i))
         EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen()));
     CheckAppListButtonIsInBounds();
   }
 
   void CheckAppListButtonIsInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
-    gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()->
-       GetBoundsInScreen();
+    gfx::Rect app_list_button_bounds =
+        shelf_view_->GetAppListButton()->GetBoundsInScreen();
     EXPECT_TRUE(visible_bounds.Contains(app_list_button_bounds));
   }
 
  private:
   ScopedTextDirectionChange text_direction_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewVisibleBoundsTest);
 };
 
 TEST_P(ShelfViewVisibleBoundsTest, ItemsAreInBounds) {
@@ skipping 102 matching lines @@
 
  private:
   // TestShelfItemDelegate:
   ShelfMenuModel* CreateApplicationMenu(int event_flags) override {
     return new TestShelfMenuModel;
   }
 
   DISALLOW_COPY_AND_ASSIGN(ListMenuShelfItemDelegate);
 };
 
+// A test implementation for AppListPresenter that does not change visibility
+// state immediately to simulate an in-flight animation. Calling
+// FinishVisibilityChange() will change the visibility to the requested one,
+// simulating end of the animation.
+class TestAppListPresenter : public app_list::AppListPresenter {
+ public:
+  TestAppListPresenter() : is_visible_(false), target_visibility_(false) {}
+  ~TestAppListPresenter() override {}
+
+  void FinishVisibilityChange() { is_visible_ = target_visibility_; }
+
+  // app_list::AppListPresenter:
+  void Show(int64_t display_id) override {
+    if (target_visibility_)

[bruthig, 2016/06/22 19:07:29]

nit: This quick return isn't adding too much value, same goes for the one in
Dismiss().

[mohsen, 2016/06/23 15:49:55]

Removed.

+      return;
+    target_visibility_ = true;
+  }
+  void Dismiss() override {
+    if (!target_visibility_)
+      return;
+    target_visibility_ = false;
+  }
+  void ToggleAppList(int64_t display_id) override {

[bruthig, 2016/06/22 19:07:29]

Interesting, I find it weird that the AppListPresenterImpl bases it's toggle off
of the current visibility as opposed to the target visibility.  Do you know if
the mus implementation does the same?

i.e. the following code is dependent on the animation timing, whereas it would
be deterministic if Toggle was based off of target visibility.

presenter_->Show(0);
presenter_->ToggleAppList(0);
...
presenter_->ToggleAppList(0);
ASSERT_EQ(true, presenter_->IsTargetVisibility());

Anyway, if we wanted to more thoroughly test the AppListButton this test fake
could be enhanced to behave in both ways but this would be going above and
beyond and I will leave it up to you if you want to do that.  If not, I think is
worth adding an explicit comment to the ToggleAppList() function or class that
says "this test double toggles based off of current visibility and not target
visibility."

[mohsen, 2016/06/23 15:49:55]

Yes, that's actually how AppListPresenterImpl prevents relaunching on a tap that
has closed it (by depending on the animation!). I believe Mus also uses
AppListPresenterImpl eventually, so that should behave the same.

I think existing test should suffice as the second way that uses target
visibility instead of the actual visibility is kind of already covered by tests
that start from a hidden app list: when user clicks on the button, the app list
gets hidden before the button receives the click and everything from that point
on is similar to when the app list was initially hidden.

Added some comments.

+    if (is_visible_)
+      Dismiss();
+    else
+      Show(display_id);
+  }
+  bool IsVisible() const override { return is_visible_; }
+  bool GetTargetVisibility() const override { return target_visibility_; }
+
+ private:
+  bool is_visible_;
+  bool target_visibility_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAppListPresenter);
+};
+
+// A test ShellDelegate implementation that returns a TestAppListPresenter as
+// the app list presenter.
+class TestAppListShellDelegate : public TestShellDelegate {
+ public:
+  TestAppListShellDelegate()
+      : app_list_presenter_(new TestAppListPresenter()) {}
+  ~TestAppListShellDelegate() override {}
+
+  TestAppListPresenter* app_list_presenter() const {
+    return app_list_presenter_.get();
+  }
+
+  // TestShellDelegate:
+  app_list::AppListPresenter* GetAppListPresenter() override {
+    return app_list_presenter();
+  }
+
+ private:
+  std::unique_ptr<TestAppListPresenter> app_list_presenter_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAppListShellDelegate);
+};
+
 }  // namespace
 
 class ShelfViewInkDropTest : public ShelfViewTest {
  public:
-  ShelfViewInkDropTest() : ink_drop_(nullptr), browser_button_(nullptr) {}
+  ShelfViewInkDropTest()
+      : app_list_button_(nullptr),
+        app_list_button_ink_drop_(nullptr),
+        browser_button_(nullptr),
+        browser_button_ink_drop_(nullptr) {}
   ~ShelfViewInkDropTest() override {}
 
   void SetUp() override {
+    shell_delegate_ = new TestAppListShellDelegate;
+    ash_test_helper()->set_test_shell_delegate(shell_delegate_);
+
     ShelfViewTest::SetUp();
 
     // TODO(mohsen): Ideally, we would want to set material mode before calling
     // ShelfViewTest::SetUp() so that everything is set up with the correct
     // material mode. Currently, this is not possible as it expects material
     // mode be UNINITIALIZED. (See https://crbug.com/620093)
     ash_md_controller_.reset(new ash::test::MaterialDesignControllerTestAPI(
-        ash::MaterialDesignController::MATERIAL_NORMAL));
-
-    browser_button_ = test_api_->GetButton(browser_index_);
-
-    views::InkDropImpl* ink_drop_impl = new views::InkDropImpl(browser_button_);
-    ink_drop_ = new InkDropSpy(base::WrapUnique(ink_drop_impl));
-    views::test::InkDropHostViewTestApi(browser_button_)
-        .SetInkDrop(base::WrapUnique(ink_drop_));
+        ash::MaterialDesignController::MATERIAL_EXPERIMENTAL));
   }
 
   void TearDown() override {
     ash_md_controller_.reset();
 
     ShelfViewTest::TearDown();
   }
 
  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_));
+  }
+
+  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() {
+    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();
+  }
+
   std::unique_ptr<ash::test::MaterialDesignControllerTestAPI>
       ash_md_controller_;
 
-  InkDropSpy* ink_drop_;
+  TestAppListShellDelegate* shell_delegate_;  // Owned by Shell.
+
+  AppListButton* app_list_button_;
+  InkDropSpy* app_list_button_ink_drop_;
   ShelfButton* browser_button_;
+  InkDropSpy* browser_button_ink_drop_;
 
  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();
+
+  ShowAppList();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  DismissAppList();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+}
+
+// Tests that when the app list is hidden, mouse press on the app list button,
+// which shows the app list, transitions ink drop states correctly. Also, tests
+// that mouse drag and mouse release does not affect the ink drop state.
+TEST_F(ShelfViewInkDropTest, AppListButtonMouseEventsWhenHidden) {
+  InitAppListButtonInkDrop();
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  generator.MoveMouseTo(app_list_button_->GetBoundsInScreen().CenterPoint());
+
+  // Mouse press on the button, which shows the app list, should end up in the
+  // activated state.
+  generator.PressLeftButton();
+  // Similar to real AppListPresenter, notify button that the app list is shown.
+  app_list_button_->OnAppListShown();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING,
+                          views::InkDropState::ACTIVATED));
+
+  // Dragging mouse out and back and releasing the button should not change the
+  // ink drop state.
+  generator.MoveMouseBy(app_list_button_->width(), 0);
+  generator.MoveMouseBy(-app_list_button_->width(), 0);
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+}
+
+// Tests that when the app list is visible, mouse press on the app list button,
+// which dismisses the app list, transitions ink drop states correctly. Also,
+// tests that mouse drag and mouse release does not affect the ink drop state.
+TEST_F(ShelfViewInkDropTest, AppListButtonMouseEventsWhenVisible) {
+  InitAppListButtonInkDrop();
+
+  // Show the app list.
+  ShowAppList();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  generator.MoveMouseTo(app_list_button_->GetBoundsInScreen().CenterPoint());
+
+  // Mouse press on the button, which dismisses the app list, should end up in
+  // the hidden state.
+  // Dismiss app list similar to pre-target handler in real AppListPresenter.
+  DismissAppList();
+  generator.PressLeftButton();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+
+  // Dragging mouse out and back and releasing the button should not change the
+  // ink drop state.
+  generator.MoveMouseBy(app_list_button_->width(), 0);
+  generator.MoveMouseBy(-app_list_button_->width(), 0);
+  generator.ReleaseLeftButton();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+}
+
+// Tests that when the app list is hidden, tapping on the app list button
+// transitions ink drop states correctly.
+TEST_F(ShelfViewInkDropTest, AppListButtonGestureTapWhenHidden) {
+  InitAppListButtonInkDrop();
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  generator.MoveMouseTo(app_list_button_->GetBoundsInScreen().CenterPoint());
+
+  // Touch press on the button should end up in the pending state.
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  // Touch release on the button, which shows the app list, should end up in the
+  // activated state.
+  generator.ReleaseTouch();
+  // Similar to real AppListPresenter, notify button that the app list is shown.
+  app_list_button_->OnAppListShown();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+}
+
+// Tests that when the app list is visible, tapping on the app list button
+// transitions ink drop states correctly.
+TEST_F(ShelfViewInkDropTest, AppListButtonGestureTapWhenVisible) {
+  InitAppListButtonInkDrop();
+
+  // Show the app list.
+  ShowAppList();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  generator.MoveMouseTo(app_list_button_->GetBoundsInScreen().CenterPoint());
+
+  // Touch press on the button, which dismisses the app list, should end up in
+  // the hidden state.
+  // Dismiss app list similar to pre-target handler in real AppListPresenter.
+  DismissAppList();
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+
+  // Touch release on the button should not change the ink drop state.
+  generator.ReleaseTouch();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+}
+
+// Tests that when the app list is hidden, tapping down on the app list button
+// and dragging the touch point transitions ink drop states correctly.
+TEST_F(ShelfViewInkDropTest, AppListButtonGestureTapDragWhenHidden) {
+  InitAppListButtonInkDrop();
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  gfx::Point touch_location =
+      app_list_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(touch_location);
+
+  // Touch press on the button should end up in the pending state.
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::ACTION_PENDING,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTION_PENDING));
+
+  // Dragging the touch point should hide the pending ink drop.
+  touch_location.Offset(app_list_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+
+  // Touch release should not change the ink drop state.
+  generator.ReleaseTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+}
+
+// Tests that when the app list is visible, tapping down on the app list button
+// and dragging the touch point transitions ink drop states correctly.
+TEST_F(ShelfViewInkDropTest, AppListButtonGestureTapDragWhenVisible) {
+  InitAppListButtonInkDrop();
+
+  // Show the app list.
+  ShowAppList();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::ACTIVATED,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::ACTIVATED));
+
+  ui::test::EventGenerator generator(shelf_view_->GetWidget()->GetNativeView());
+  gfx::Point touch_location =
+      app_list_button_->GetBoundsInScreen().CenterPoint();
+  generator.MoveMouseTo(touch_location);
+
+  // Touch press on the button, which dismisses the app list, should end up in
+  // the hidden state.
+  // Dismiss app list similar to pre-target handler in real AppListPresenter.
+  DismissAppList();
+  generator.PressTouch();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::DEACTIVATED));
+
+  // Dragging the touch point and releasing should not change the ink drop
+  // state.
+  touch_location.Offset(app_list_button_->width(), 0);
+  generator.MoveTouch(touch_location);
+  generator.ReleaseTouch();
+  FinishAppListVisibilityChange();
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            app_list_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(app_list_button_ink_drop_->GetAndResetRequestedStates(),
+              ElementsAre(views::InkDropState::HIDDEN));
+}
+
 // Tests that clicking on a shelf item that does not show a menu transitions ink
 // drop states correctly.
-TEST_F(ShelfViewInkDropTest, WithoutMenuPressRelease) {
+TEST_F(ShelfViewInkDropTest, ShelfButtonWithoutMenuPressRelease) {
+  InitBrowserButtonInkDrop();
+
   views::CustomButton* button = browser_button_;
-  gfx::Point press_location = button->GetLocalBounds().CenterPoint();
-
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, press_location,
-                             press_location, ui::EventTimeForNow(),
+  gfx::Point mouse_location = button->GetLocalBounds().CenterPoint();
+
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, mouse_location,
+                             mouse_location, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMousePressed(press_event);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
-            ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_PENDING));
 
-  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, press_location,
-                               press_location, ui::EventTimeForNow(),
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, mouse_location,
+                               mouse_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_TRIGGERED));
 }
 
 // Tests that dragging outside of a shelf item transitions ink drop states
 // correctly.
-TEST_F(ShelfViewInkDropTest, WithoutMenuPressDragReleaseOutside) {
+TEST_F(ShelfViewInkDropTest, ShelfButtonWithoutMenuPressDragReleaseOutside) {
+  InitBrowserButtonInkDrop();
+
   views::CustomButton* button = browser_button_;
-  gfx::Point press_location = button->GetLocalBounds().CenterPoint();
-
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, press_location,
-                             press_location, ui::EventTimeForNow(),
+  gfx::Point mouse_location = button->GetLocalBounds().CenterPoint();
+
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, mouse_location,
+                             mouse_location, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMousePressed(press_event);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
-            ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_PENDING));
 
-  press_location.Offset(test_api_->GetMinimumDragDistance() / 2, 0);
-  ui::MouseEvent drag_event_small(ui::ET_MOUSE_DRAGGED, press_location,
-                                  press_location, ui::EventTimeForNow(),
+  mouse_location.Offset(test_api_->GetMinimumDragDistance() / 2, 0);
+  ui::MouseEvent drag_event_small(ui::ET_MOUSE_DRAGGED, mouse_location,
+                                  mouse_location, ui::EventTimeForNow(),
                                   ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseDragged(drag_event_small);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
-            ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(), IsEmpty());
-
-  press_location.Offset(test_api_->GetMinimumDragDistance(), 0);
-  ui::MouseEvent drag_event_large(ui::ET_MOUSE_DRAGGED, press_location,
-                                  press_location, ui::EventTimeForNow(),
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  mouse_location.Offset(test_api_->GetMinimumDragDistance(), 0);
+  ui::MouseEvent drag_event_large(ui::ET_MOUSE_DRAGGED, mouse_location,
+                                  mouse_location, ui::EventTimeForNow(),
                                   ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseDragged(drag_event_large);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::HIDDEN));
 
-  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, press_location,
-                               press_location, ui::EventTimeForNow(),
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, mouse_location,
+                               mouse_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(), IsEmpty());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
 }
 
 // Tests that dragging outside of a shelf item and back transitions ink drop
 // states correctly.
-TEST_F(ShelfViewInkDropTest, WithoutMenuPressDragReleaseInside) {
+TEST_F(ShelfViewInkDropTest, ShelfButtonWithoutMenuPressDragReleaseInside) {
+  InitBrowserButtonInkDrop();
+
   views::CustomButton* button = browser_button_;
-  gfx::Point press_location = button->GetLocalBounds().CenterPoint();
-
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, press_location,
-                             press_location, ui::EventTimeForNow(),
+  gfx::Point mouse_location = button->GetLocalBounds().CenterPoint();
+
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, mouse_location,
+                             mouse_location, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMousePressed(press_event);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
-            ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_PENDING));
 
-  press_location.Offset(test_api_->GetMinimumDragDistance() * 2, 0);
-  ui::MouseEvent drag_event_outside(ui::ET_MOUSE_DRAGGED, press_location,
-                                    press_location, ui::EventTimeForNow(),
+  mouse_location.Offset(test_api_->GetMinimumDragDistance() * 2, 0);
+  ui::MouseEvent drag_event_outside(ui::ET_MOUSE_DRAGGED, mouse_location,
+                                    mouse_location, ui::EventTimeForNow(),
                                     ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseDragged(drag_event_outside);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::HIDDEN));
 
-  press_location.Offset(-test_api_->GetMinimumDragDistance() * 2, 0);
-  ui::MouseEvent drag_event_inside(ui::ET_MOUSE_DRAGGED, press_location,
-                                   press_location, ui::EventTimeForNow(),
+  mouse_location.Offset(-test_api_->GetMinimumDragDistance() * 2, 0);
+  ui::MouseEvent drag_event_inside(ui::ET_MOUSE_DRAGGED, mouse_location,
+                                   mouse_location, ui::EventTimeForNow(),
                                    ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseDragged(drag_event_inside);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(), IsEmpty());
-
-  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, press_location,
-                               press_location, ui::EventTimeForNow(),
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
+
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, mouse_location,
+                               mouse_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(), IsEmpty());
+  EXPECT_EQ(views::InkDropState::HIDDEN,
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
+              IsEmpty());
 }
 
 // Tests that clicking on a shelf item that shows an app list menu transitions
 // ink drop state correctly.
-TEST_F(ShelfViewInkDropTest, WithMenuPressRelease) {
+TEST_F(ShelfViewInkDropTest, ShelfButtonWithMenuPressRelease) {
+  InitBrowserButtonInkDrop();
+
   // Set a delegate for the shelf item that returns an app list menu.
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ListMenuShelfItemDelegate* list_menu_delegate = new ListMenuShelfItemDelegate;
   item_manager_->SetShelfItemDelegate(browser_shelf_id,
                                       base::WrapUnique(list_menu_delegate));
 
   views::CustomButton* button = browser_button_;
-  gfx::Point press_location = button->GetLocalBounds().CenterPoint();
+  gfx::Point mouse_location = button->GetLocalBounds().CenterPoint();
 
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, press_location,
-                             press_location, ui::EventTimeForNow(),
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, mouse_location,
+                             mouse_location, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMousePressed(press_event);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
-            ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+            browser_button_ink_drop_->GetTargetInkDropState());
+  EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_PENDING));
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ShelfViewTestAPI::CloseMenu,
                             base::Unretained(test_api_.get())));
 
   // Mouse release will spawn a menu which will then get closed by the above
   // posted task.
-  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, press_location,
-                               press_location, ui::EventTimeForNow(),
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, mouse_location,
+                               mouse_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
-  EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
-  EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
+  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 test
 }  // namespace ash