[ash-md] Fixed MenuButton focus appearing after dismissing menus.

ui/views/controls/button/menu_button_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/controls/button/menu_button.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/animation/test/ink_drop_host_view_test_api.h"
 #include "ui/views/animation/test/test_ink_drop.h"
 #include "ui/views/controls/button/menu_button_listener.h"
@@ skipping 55 matching lines @@
   void CreateMenuButtonWithNoListener() { CreateMenuButton(nullptr); }
 
   // Creates a MenuButton with a MenuButtonListener. In this case, when the
   // MenuButton is pushed, it notifies the MenuButtonListener to open a
   // drop-down menu.
   void CreateMenuButtonWithMenuButtonListener(
       MenuButtonListener* menu_button_listener) {
     CreateMenuButton(menu_button_listener);
   }
 
-  void AttachInkDrop() {
-    ink_drop_ = new test::TestInkDrop();
-    test::InkDropHostViewTestApi(button_).SetInkDrop(
-        base::WrapUnique(ink_drop_));
+  gfx::Point GetOutOfButtonLocation() const {
+    return gfx::Point(button_->x() - 1, button_->y() - 1);
   }
 
  private:
   void CreateMenuButton(MenuButtonListener* menu_button_listener) {
     CreateWidget();
     generator_.reset(new ui::test::EventGenerator(widget_->GetNativeWindow()));
     // Set initial mouse location in a consistent way so that the menu button we
     // are about to create initializes its hover state in a consistent manner.
     generator_->set_current_location(gfx::Point(10, 10));
 
     button_ = new TestMenuButton(menu_button_listener);
     button_->SetBoundsRect(gfx::Rect(0, 0, 200, 20));
+
+    ink_drop_ = new test::TestInkDrop();
+    test::InkDropHostViewTestApi(button_).SetInkDrop(
+        base::WrapUnique(ink_drop_));
+
     widget_->SetContentsView(button_);
-
     widget_->Show();
   }
 
   void CreateWidget() {
     DCHECK(!widget_);
 
     widget_ = new Widget;
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.bounds = gfx::Rect(0, 0, 200, 200);
@@ skipping 75 matching lines @@
   void set_menu_button(MenuButton* menu_button) { menu_button_ = menu_button; }
 
   void OnMenuButtonClicked(MenuButton* source,
                            const gfx::Point& point,
                            const ui::Event* event) override {
     pressed_lock_.reset(new MenuButton::PressedLock(menu_button_));
     if (release_lock_)
       pressed_lock_.reset();
   }
 
+  void ReleasePressedLock() { pressed_lock_.reset(); }
+
  private:
   MenuButton* menu_button_;
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock_;
 
   // The |pressed_lock_| will be released when true.
   bool release_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PressStateMenuButtonListener);
 };
@@ skipping 255 matching lines @@
   generator()->PressLeftButton();
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 
   generator()->ReleaseLeftButton();
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 TEST_F(MenuButtonTest, InkDropStateForMenuButtonActivationsWithoutListener) {
   CreateMenuButtonWithNoListener();
-  AttachInkDrop();
   ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::HIDDEN, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonActivationsWithListenerThatDoesntAcquireALock) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  AttachInkDrop();
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::ACTION_TRIGGERED,
             ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(
     MenuButtonTest,
     InkDropStateForMenuButtonActivationsWithListenerThatDontReleaseAllLocks) {
   PressStateMenuButtonListener menu_button_listener(false);
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  AttachInkDrop();
   menu_button_listener.set_menu_button(button());
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonActivationsWithListenerThatReleaseAllLocks) {
   PressStateMenuButtonListener menu_button_listener(true);
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   menu_button_listener.set_menu_button(button());
-  AttachInkDrop();
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest, InkDropStateForMenuButtonsWithPressedLocks) {
   CreateMenuButtonWithNoListener();
-  AttachInkDrop();
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   pressed_lock1.reset();
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   pressed_lock2.reset();
   EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 // Verifies only one ink drop animation is triggered when multiple PressedLocks
 // are attached to a MenuButton.
 TEST_F(MenuButtonTest, OneInkDropAnimationForReentrantPressedLocks) {
   CreateMenuButtonWithNoListener();
-  AttachInkDrop();
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
   ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTION_PENDING, ink_drop()->GetTargetInkDropState());
 }
 
 // Verifies the InkDropState is left as ACTIVATED if a PressedLock is active
 // before another Activation occurs.
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonWithPressedLockBeforeActivation) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  AttachInkDrop();
   MenuButton::PressedLock lock(button());
 
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 #if defined(USE_AURA)
 
 // Tests that the MenuButton does not become pressed if it can be dragged, and a
@@ skipping 70 matching lines @@
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   generator()->MoveTouch(gfx::Point(10, 30));
   generator()->ReleaseTouch();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 }
 
 #endif  // !defined(OS_MACOSX) || defined(USE_AURA)
 
+TEST_F(MenuButtonTest, InkDropHoverWhenShowingMenu) {
+  PressStateMenuButtonListener menu_button_listener(false);
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  menu_button_listener.set_menu_button(button());
+
+  generator()->MoveMouseTo(GetOutOfButtonLocation());
+  EXPECT_FALSE(ink_drop()->is_hovered());
+
+  generator()->MoveMouseTo(button()->bounds().CenterPoint());
+  EXPECT_TRUE(ink_drop()->is_hovered());
+
+  generator()->PressLeftButton();
+  EXPECT_FALSE(ink_drop()->is_hovered());
+}
+
+TEST_F(MenuButtonTest, InkDropIsHoveredAfterDismissingMenuWhenMouseOverButton) {
+  PressStateMenuButtonListener menu_button_listener(false);
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  menu_button_listener.set_menu_button(button());
+
+  generator()->MoveMouseTo(button()->bounds().CenterPoint());
+  generator()->PressLeftButton();
+  EXPECT_FALSE(ink_drop()->is_hovered());
+  menu_button_listener.ReleasePressedLock();
+
+  EXPECT_TRUE(ink_drop()->is_hovered());
+}
+
+TEST_F(MenuButtonTest,
+       InkDropIsntHoveredAfterDismissingMenuWhenMouseOutsideButton) {
+  PressStateMenuButtonListener menu_button_listener(false);
+  CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  menu_button_listener.set_menu_button(button());
+
+  generator()->MoveMouseTo(button()->bounds().CenterPoint());
+  generator()->PressLeftButton();
+  generator()->MoveMouseTo(GetOutOfButtonLocation());
+  menu_button_listener.ReleasePressedLock();
+
+  EXPECT_FALSE(ink_drop()->is_hovered());
+}
+
 }  // namespace views