MacViews: Fix views_unittests MenuButtonTest.{ActivateDropDownOnMouseClick,DraggableMenuButtonActiv…

ui/views/controls/button/menu_button_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/controls/button/menu_button.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/wm/public/drag_drop_client.h"
 #endif
 
 using base::ASCIIToUTF16;
 
 namespace views {
 
 class MenuButtonTest : public ViewsTestBase {
  public:
-  MenuButtonTest() : widget_(nullptr), button_(nullptr) {}
+  MenuButtonTest() : generator(nullptr), widget_(nullptr), button_(nullptr) {}

[tapted, 2016/02/09 05:06:41]

nit: doesn't need an initializer now that it's a scoped_ptr

[Patti Lor, 2016/02/12 04:42:20]

Done.

   ~MenuButtonTest() override {}
 
   void TearDown() override {
     if (widget_ && !widget_->IsClosed())

[tapted, 2016/02/09 05:06:41]

nit: although it's not crashing.... since the generator is constructed with the
Widget's window, and the window is about to be destroyed, we should reset the
generator before this to properly preserve nested object lifetimes.

[Patti Lor, 2016/02/12 04:42:20]

Done.

       widget_->Close();
 
     ViewsTestBase::TearDown();
   }
 
   Widget* widget() { return widget_; }
   MenuButton* button() { return button_; }
 
  protected:
   // Creates a MenuButton with no button listener.
   void CreateMenuButtonWithNoListener() { CreateMenuButton(nullptr, nullptr); }
 
   // Creates a MenuButton with a ButtonListener. In this case, the MenuButton
   // acts like a regular button.
   void CreateMenuButtonWithButtonListener(ButtonListener* button_listener) {
     CreateMenuButton(button_listener, 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(nullptr, menu_button_listener);
   }
 
+  scoped_ptr<ui::test::EventGenerator> generator;

[tapted, 2016/02/09 05:06:41]

generator -> generator_

also, this should go back to private: so that it's consistent with widget() and
button() 

(test harnesses are allowed to have protected members, but consistency trumps
quite a lot in the style guide)

[Patti Lor, 2016/02/12 04:42:20]

Having the generator scoped_ptr be private means I can't return it from a getter
function (can't move/copy scoped_ptrs).

[tapted, 2016/02/12 04:44:54]

returning generator_.get() is fine for this kind of stuff :)

+
  private:
   void CreateMenuButton(ButtonListener* button_listener,
                         MenuButtonListener* menu_button_listener) {
     CreateWidget();
+    generator = make_scoped_ptr(new ui::test::EventGenerator(GetContext(),

[tapted, 2016/02/09 05:06:41]

nit: make_scoped_ptr is used mostly after a `return`. If you have the scoped_ptr
itself, it's more conventional to do

generator_.reset(new ...)

[Patti Lor, 2016/02/12 04:42:20]

Done.

+        widget_->GetNativeWindow()));
 
     const base::string16 label(ASCIIToUTF16("button"));
     button_ =
         new MenuButton(button_listener, label, menu_button_listener, false);
     button_->SetBoundsRect(gfx::Rect(0, 0, 200, 20));
     widget_->SetContentsView(button_);
 
     widget_->Show();
   }
 
   void CreateWidget() {
     DCHECK(!widget_);
 
     widget_ = new Widget;
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     widget_->Init(params);
   }
 
   Widget* widget_;
   MenuButton* button_;
+
+  DISALLOW_COPY_AND_ASSIGN(MenuButtonTest);
 };
 
 class TestButtonListener : public ButtonListener {
  public:
   TestButtonListener()
       : last_sender_(nullptr),
         last_sender_state_(Button::STATE_NORMAL),
         last_event_type_(ui::ET_UNKNOWN) {}
   ~TestButtonListener() override {}
 
@@ skipping 171 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(TestShowSiblingButtonListener);
 };
 
 // Tests if the listener is notified correctly, when a mouse click happens on a
 // MenuButton that has a regular ButtonListener.
 TEST_F(MenuButtonTest, ActivateNonDropDownOnMouseClick) {
   TestButtonListener button_listener;
   CreateMenuButtonWithButtonListener(&button_listener);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.ClickLeftButton();
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->ClickLeftButton();
 
   // Check that MenuButton has notified the listener on mouse-released event,
   // while it was in hovered state.
   EXPECT_EQ(button(), button_listener.last_sender());
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, button_listener.last_event_type());
   EXPECT_EQ(Button::STATE_HOVERED, button_listener.last_sender_state());
 }
 
 // Tests if the listener is notified correctly when a mouse click happens on a
 // MenuButton that has a MenuButtonListener.
 TEST_F(MenuButtonTest, ActivateDropDownOnMouseClick) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.ClickLeftButton();
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->ClickLeftButton();
 
   // Check that MenuButton has notified the listener, while it was in pressed
   // state.
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 // Test that the MenuButton stays pressed while there are any PressedLocks.
 TEST_F(MenuButtonTest, MenuButtonPressedLock) {
   CreateMenuButtonWithNoListener();
 
   // Move the mouse over the button; the button should be in a hovered state.
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-  generator.MoveMouseTo(gfx::Point(10, 10));
+  generator->MoveMouseTo(gfx::Point(10, 10));
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   // Introduce a PressedLock, which should make the button pressed.
   scoped_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Even if we move the mouse outside of the button, it should remain pressed.
-  generator.MoveMouseTo(gfx::Point(300, 10));
+  generator->MoveMouseTo(gfx::Point(300, 10));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Creating a new lock should obviously keep the button pressed.
   scoped_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // The button should remain pressed while any locks are active.
   pressed_lock1.reset();
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Reseting the final lock should return the button's state to normal...
   pressed_lock2.reset();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
 
   // ...And it should respond to mouse movement again.
-  generator.MoveMouseTo(gfx::Point(10, 10));
+  generator->MoveMouseTo(gfx::Point(10, 10));
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   // Test that the button returns to the appropriate state after the press; if
   // the mouse ends over the button, the button should be hovered.
   pressed_lock1.reset(new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
   pressed_lock1.reset();
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   // If the button is disabled before the pressed lock, it should be disabled
   // after the pressed lock.
   button()->SetState(Button::STATE_DISABLED);
   pressed_lock1.reset(new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
   pressed_lock1.reset();
   EXPECT_EQ(Button::STATE_DISABLED, button()->state());
 
-  generator.MoveMouseTo(gfx::Point(300, 10));
+  generator->MoveMouseTo(gfx::Point(300, 10));
 
   // Edge case: the button is disabled, a pressed lock is added, and then the
   // button is re-enabled. It should be enabled after the lock is removed.
   pressed_lock1.reset(new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
   button()->SetState(Button::STATE_NORMAL);
   pressed_lock1.reset();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
 }
 
 // Test that if a sibling menu is shown, the original menu button releases its
 // PressedLock.
 TEST_F(MenuButtonTest, PressedStateWithSiblingMenu) {
   TestShowSiblingButtonListener listener;
   CreateMenuButtonWithMenuButtonListener(&listener);
 
   // Move the mouse over the button; the button should be in a hovered state.
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-  generator.MoveMouseTo(gfx::Point(10, 10));
+  generator->MoveMouseTo(gfx::Point(10, 10));
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
-  generator.ClickLeftButton();
+  generator->ClickLeftButton();
   // Test is continued in TestShowSiblingButtonListener::OnMenuButtonClicked().
 }
 
 // Test that the MenuButton does not become pressed if it can be dragged, until
 // a release occurs.
 TEST_F(MenuButtonTest, DraggableMenuButtonActivatesOnRelease) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   TestDragController drag_controller;
   button()->set_drag_controller(&drag_controller);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.PressLeftButton();
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->PressLeftButton();
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 
-  generator.ReleaseLeftButton();
+  generator->ReleaseLeftButton();
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 #if defined(USE_AURA)
 
 // Tests that the MenuButton does not become pressed if it can be dragged, and a
 // DragDropClient is processing the events.
 TEST_F(MenuButtonTest, DraggableMenuButtonDoesNotActivateOnDrag) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   TestDragController drag_controller;
   button()->set_drag_controller(&drag_controller);
 
   TestDragDropClient drag_client;
   SetDragDropClient(GetContext(), &drag_client);
   button()->PrependPreTargetHandler(&drag_client);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.DragMouseBy(10, 0);
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->DragMouseBy(10, 0);
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_NORMAL, menu_button_listener.last_source_state());
 }
 
 #endif  // USE_AURA
 
 // No touch on desktop Mac. Tracked in http://crbug.com/445520.
 #if !defined(OS_MACOSX) || defined(USE_AURA)
 
 // Tests if the listener is notified correctly when a gesture tap happens on a
 // MenuButton that has a regular ButtonListener.
 TEST_F(MenuButtonTest, ActivateNonDropDownOnGestureTap) {
   TestButtonListener button_listener;
   CreateMenuButtonWithButtonListener(&button_listener);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-
   // Move the mouse outside the menu button so that it doesn't impact the
   // button state.
-  generator.MoveMouseTo(400, 400);
+  generator->MoveMouseTo(400, 400);
   EXPECT_FALSE(button()->IsMouseHovered());
 
-  generator.GestureTapAt(gfx::Point(10, 10));
+  generator->GestureTapAt(gfx::Point(10, 10));
 
   // Check that MenuButton has notified the listener on gesture tap event, while
   // it was in hovered state.
   EXPECT_EQ(button(), button_listener.last_sender());
   EXPECT_EQ(ui::ET_GESTURE_TAP, button_listener.last_event_type());
   EXPECT_EQ(Button::STATE_HOVERED, button_listener.last_sender_state());
 
   // The button should go back to it's normal state since the gesture ended.
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
 }
 
 // Tests if the listener is notified correctly when a gesture tap happens on a
 // MenuButton that has a MenuButtonListener.
 TEST_F(MenuButtonTest, ActivateDropDownOnGestureTap) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
 
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-
   // Move the mouse outside the menu button so that it doesn't impact the
   // button state.
-  generator.MoveMouseTo(400, 400);
+  generator->MoveMouseTo(400, 400);
   EXPECT_FALSE(button()->IsMouseHovered());
 
-  generator.GestureTapAt(gfx::Point(10, 10));
+  generator->GestureTapAt(gfx::Point(10, 10));
 
   // Check that MenuButton has notified the listener, while it was in pressed
   // state.
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 
   // The button should go back to it's normal state since the gesture ended.
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
 }
 
 // Tests that the button enters a hovered state upon a tap down, before becoming
 // pressed at activation.
 TEST_F(MenuButtonTest, TouchFeedbackDuringTap) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.PressTouch();
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->PressTouch();
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
-  generator.ReleaseTouch();
+  generator->ReleaseTouch();
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 // Tests that a move event that exits the button returns it to the normal state,
 // and that the button did not activate the listener.
 TEST_F(MenuButtonTest, TouchFeedbackDuringTapCancel) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
-  generator.set_current_location(gfx::Point(10, 10));
-  generator.PressTouch();
+  generator->set_current_location(gfx::Point(10, 10));
+  generator->PressTouch();
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
-  generator.MoveTouch(gfx::Point(10, 30));
-  generator.ReleaseTouch();
+  generator->MoveTouch(gfx::Point(10, 30));
+  generator->ReleaseTouch();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 }
 
 #endif  // !defined(OS_MACOSX) || defined(USE_AURA)
 
 }  // namespace views